GitHub Copilot - The World’s Most Widely Adopted AI Developer Tool (Repeat)

[upbeat music] Well, I hope that everybody, um, has had a great first half of your day, uh, so far and had a good lunch.

Thank you all for being here. Um, this is a talk, this is gonna be a workshop, uh, about, uh, the world's most widely adopted devel-- AI developer tool, and that of course is GitHub Copilot.

I'm Christina Warren. I'm a senior developer advocate at GitHub, and I'm going to be assisted today in this workshop by my colleagues Dave, Alex, and Harald, who are all here in the front.

Uh, and, and well, um, um, uh, Alex is in the back, so we, we've got people, um, sorted around. Um, we did a version of this workshop earlier, um, this morning.

Uh, this is gonna be our second, uh, uh, try at it. We learned some things, so we'll see how things go. Um, and then as we go along, if you have any questions or if you need help, um, w- I will have some resources where you can, um, get help, um, online in, in GitHub, but also feel

free to raise your hand, and we will do what we can to help you out. And, uh, this is just kinda gonna be a little bit of an overview of how we're going to be doing this today.

So we're gonna start off with an overview of GitHub Copilot, and then we're going to talk about, uh, getting set up and, and access, um, for the, the repository that we'll be working out of and, um, getting access to GitHub Copilot if you don't already have access.

Um, I would love, just out of curiosity, uh, for the people in the room, how many of you have used GitHub Copilot before?

Okay. Awesome. Awesome. Um, that's great to see. Um, we also will have, um, uh, some resource links, um, then we're gonna get into the labs, and then of course, we will be doing some feedback.

This right here, this QR code, and I'm sorry that I was not able to make the URL larger, but this is, um, going to be kind of ground zero for this workshop, this repository.

So, um, if, if you wanna follow along with us, going to this, uh, URL, gh.io/aifair-workshop, is going to take you to a repository which will show you everything that you need, um, to, uh, to get, uh, is in this repository.

This slide deck is also in that repository, so if there's anything you want from that, um, that, that has been, um, added to that as well. But this is gonna be our central resource and where we're going to be working.

Um, I will have this up again, um, a little bit, uh, later, but if you wanna go ahead and, um, either, either go to this URL now or use the QR code, that would be great.

All right. So let's just do a little bit of an overview about GitHub Copilot, which is your AI pair programmer. Okay. So GitHub Copilot is, um, an extension. I mean, well, it works in multiple places actually.

Uh, we're, we're not gonna talk too much about the integration for, um, GitHub, um, Enterprise and, and some of the things we're doing on, on github.com. We're gonna primarily be focused on the, the experience inside your IDE.

Um, but, uh, this is, you know, one of the very first, uh, coding assistants. Uh, it was introduced in, uh, private preview in 2021, formally released in 2022. So we've been at this a while now, and basically, it's gonna be using the context that you provided, and then it's going to synthesize code to match that context.

And so using files that you have open, tabs that you have open in your editor, as well as comments that, that you're writing, or you can query directly with GitHub Copilot Chat in, in a chat interface to get coding suggestions, um, to, you know, convert comments into code.

So I can make a comment say, you know, "Write, write a function," um, to parse the URL, um, or to autofill for repetitive code if I'm using the same code block over and over again and the same pattern over and over again.

Uh, Copilot is going to know how to do that. It can also help streamline creating tests and show, you know, alternative ways of, of achieving, um, the same task.

And as I said, you know, this is your copilot for an AI-powered software development life cycle. Like, we're, we're taking place in the IDE and the terminal. Uh, we have support for Visual Studio Code, which is what we're going to be showing off.

Um, Visual Studio also has support for, for, uh, uh, GitHub Copilot, as well as a number of the JetBrains IDEs, and there's also a Neovim, um, extension, which, uh, I learned last, uh, session actually does have some GitHub Copilot chat support, which is cool.

Um, and, um, Copilot beyond that also can work on github.com. And so if you have an Enterprise account and have GitHub Copilot for Enterprise, there are different things you can do on github.com to also integrate, uh, w- with Copilot to aid in, in the creation of, of pull requests and in, um, uh, uh, fixing, um, potentially insecure

code and, uh, you know, uh, even we're going to have a session tomorrow with one of our colleagues kind of going from ideation of a, kind of an idea of, of how you wanna plan something out to actually implementing that whole plan.

Um, and so one of the questions that we get a lot is,

"Is Copilot training, uh, you know, the, the model on my, um, data?" And, and the answer to that, to my coding data, and, and the answer to that is no.

There is an option if you want to contribute- ... your, um, uh, code completion stuff into the larger model, but that can be turned off, and, and by default, that is off for business and enterprise accounts.

And so how this is working is we are actually just taking the context from the editor and, and, uh, my colleague Harald can talk a little bit more about how that's working and, and kind of getting an idea of what I'm doing.

That's going to be sending it to OpenAI's, uh, GPT model, and then sending suggestions back. Now, that model itself has been trained on public source cord, um, uh, source code and, and that's how that's gotten better.

But your code itself is, is not feeding, feeding our model. Um, there's an option, as I said, if you wanted to do that, but that, that is not how it works, um, by design.

Um, so some of the, again, some of the answers to the common questions. You know, "Does it, it train on my code?" No. When you're using it for, for business or for enterprise, none of your code i- is stored by GitHub, and even on the individual plans, there's an option to be able to, to turn that feature

off. Um, what is included in the context? So this is going to be the files that you're working on, and so that could be, you know, uh, tabs that are open in your IDE starting from the current file.

Um, and you know, another question we often get is, you know, "Can't I just, you know, write the code on my own?" Well, yeah, but how often have you ever been in a situation where you have to write the same piece of boilerplate code over and over and over again, and oftentimes doing the same thing with minor

changes? Uh, we love to automate ourselves out of jobs, make things easier on us so we can focus on things that we actually enjoy doing more, and this is one of the great things about, I think, AI and about, um, uh, coding assistants like Copilot in general.

So one of the features that we introduced, gosh, I guess it was

a year and a half ago now, is GitHub Copilot Chat, which basically brings kind of a ChatGPT-like experience into your editor. So you can actually chat directly inside your editor with Copilot, um, and, and you can ask questions.

You can also ask for specific queries about the code that is in your editor itself. So you can say-- you can select some code and say, "Hey, how can I optimize this?

How can I make this better?" Or, "Write me a b- a, a unit test for this code," and it can do that. You can also ask more general queries.

It's also great for being able to translate, you know, code from one language to another. Um, sometimes that actually works really well. Um, you'd be surprised. And um, it can also, you know, ask it to propose fixes for bugs and to help make code more secure.

And this support for Copilot Chat is in VS Code, Visual Studio, JetBrains, and as we learned recently, yes, um, Neovim. Um, how well it works in Neovim, I, I don't think all the, the features are quite there, but it is there.

And one of the things when we talk about... And, and we're gonna be getting to d- some demos in just a second. Uh, but one of the things that we talk a lot about when we talk about, you know, uh, coding assistants are, are prompt crafting, because a lot about how well these things works depends on what

prompts you're writing and, and what, um, information you're giving, um, Copilot. Because again, it is a copilot. It is not doing it for you. And so writing good prompts can help get better results.

And so some of the, the ways that we've seen that really improve, um, is by making sure that you have the right amount of context. This can be really useful.

A- again, like I said, having what, what tabs you have open, starting with, like, the, the, um, most recent file, um, or the centr- central most file rather, um, and, and what other files are open.

That can g- provide Copilot with context about what you're doing. Also, if you put things in a comment, um, about what you're trying to do, or even in some cases giving it, you know, an example of code that you want it to replicate or, or that, that represents what you're trying to achieve, that can go a long

way with helping Copilot understand what you're trying to achieve. Um, a- also being very clear about what your intent is and, and making that clear in your prompt. You know, "I, I want to create a function to parse a URL."

This is actually going to be one of the examples in the labs. Being very specific about what purpose you have in mind in that prompt. Being vague can work okay, um, but the more specific you can be, the better results you're going to get.

Um, also focusing on clarity, being easy to understand. That's going to also help the, the AI, uh, give better results. And being specific, and, and, and that means, you know, saying, "Okay, I, I, I don't want it to look like this.

I want it to look like this." So being, uh, detailed and precise will also go a long way, um, at getting the most out of Copilot. And the workshop that we have will go through all these different steps.

Yes.

Yes. Now we have time for questions.

Sure.

Uh, so regarding the context, is there any way to control it better? Like, I would assume that we want just to control...

So everybody can hear you from here.

Yeah.

Uh, so like the... Oh, okay.

Cool. Uh-

Can we get the second mic on?

Maybe it has below red.

Try that.

Sorry about that.

No, this is not your fault. There we go.

Okay.

All right.

There we go. Yay.

So the question was about, uh, the context that we provide to, to Copilot.

Mm-hmm.

Is there any way to have more control over it? So I assume that given the context length, that GitHub does some smart things underneath to, to kind of, uh, um, make it smaller.

So obviously it won't load all of the 10 full pages of 2,000 lou- lines of codes. Um, and sometimes it will give you subpar results because of that, because obviously it doesn't know the exact-

Right

... method that I have in mind right now. Um, so yeah, uh, how about that?

Actually, I'm, I'm gonna let, uh, my colleague Harald answer that question 'cause he's got, has way more insight into this than I do.

Second, uh, uh, there's also a talk tomorrow, I think at the Booth Theater. We're gonna go more into context as well. So there's an attach button. Once you open chat, you will see you can ac-actually reference files specifically.

Uh, so that's one way. Um, otherwise, the, the best surefire way, if you have code selected that you wanna talk about, Copilot will include it as long as it fits into the context window, and that's, that's kind of the, the best trick to keep in mind, just having code selected.

Same for inline chat as well, if you try that out. Um-

The attach button have been there for long?

No. No, it hasn't. It just came in the last release, so, uh, i- uh, uh, so it's a sneak preview to tomorrow's show. [laughs] Um, but otherwise, the [REDACTED:username], if you try that out, that's in the, in the plan as well.

That will give you a more general overview, uh, of your project, uh, using kind of rack techniques and, and giving context, uh,

re-related to the question. So the better you ask a question to code patterns that are actually in your code base, the more it will find. It will show you.

Ch- always check the references, uh, that are, that you see in chat to see what context is being used. So that's kind of the main, main tips there.

Yeah, and there's a question in the back.

Yeah, my voice not sure if you can. Yeah, sure. I'll just project. Uh, so, uh, to follow up on the question that was just asked, one of the things that I've, uh, dealt with is the same problem where it seems like I don't have the full context being loaded in when I ask questions.

Just a question on terms of best practice. If I reference a method that exists in another file, is that method still being loaded in in the context if I ask a question, or do I need to explicitly have that file open as a tab?

You can use the attach button there as well, and we're working on that you can also attach symbols from your code base. So that will be also possible.

And so as a best-

Yeah

... best practice then, I always need to bring in the additional context.

Yeah.

It's not smart enough to figure out that I'm calling a function from a different file.

Not, not yet. We're working on that as well. So that's, there's definitely more in-in-inference coming, but as that can easily go, go wrong, as for sh- given the broad s-- lots of questions people can ask.

So the, the more explicit... If you know what you're talking about, just show it to Copilot, just like you would do with anybody else.

But can you attach your whole folder or file by-

That's, uh, [REDACTED:username]. Yeah, so @, [REDACTED:username] is a, is a rack pattern where we look at the whole code base.

Yeah.

But it won't be fully in context then.

Yeah. Not, not the thing. Yeah.

Awesome. Awesome. Yeah, and if you, if you continue to have more questions, yeah, please just raise your hands, um, because this is great, and, um, we have really good people here to answer those questions.

Um, a-again, some additional, like, good best practices. Using good names. Sorry, go on. Yeah, David.

No, I was just gonna say one, one... We'll refer in a little bit to we've set up discussions, GitHub discussions, and similar question came up this morning. So we already have a set of links out there to dive into different resources to learn about exactly everything that Copilot pulls in for context.

You know, so from that, you can-- you've got some documentation and references to dig into, uh, to, to figure out in your situation, your situation, what's gonna work best.

Yeah. And, and also attend Harald's talk tomorrow too, um, because, uh, it, that, that, that, that is a plug for you, Harald. Thank you very much. Um, but yeah, um, um, just, just quickly going ahead.

Um, this, uh, this, uh, is linked in the main repo that I, that I linked to before. This is the Discussions tab, but this also goes directly there. So if you want to, um, if you have any questions during the workshop or if, if you wanna see some of the previous, uh, questions that were asked before, we've

got that stuff there as well. Um, so, um, again, just real quickly, some best practices in addition to offering context, because that is an important thing. Using good names, because Copilot is designed to understand natural language, so not being, you know, uh, using, uh, overly genericized things, actually giving things names the way you would actually name a,

a, a function or a class is useful. Spelling out variable names. You know, single letter variables and abbreviations can be ambiguous, so if you can spell those out and be specific with them, you can get better results.

Um, keeping functions functional, um, is, is, is a good thing too. And, and then the, the biggest thing, honestly, is being consistent. So, you know, the generated code is going to follow contextual patterns.

And so again, to what Harald was mentioning before, if you select some code and you can offer that as context specifically in addition to attaching code, um, that, that new, uh, feature that, uh, th- uh, just, uh, recently shipped, um, that will help, um, get better code too.

But, but yeah, I mean, good code does beget better code. And so one of, I think, the misnomers, um, about a lot of the coding assistance is that it's really primarily aimed at people who aren't, um, skilled developers.

And, and that's true that it can help people who don't have, um, a strong development background, but I think what we've found in the last three years is that the people who really get the most out of this are people who are developers day in and day out and who do work a lot with it because they

are, are getting the most, um, uh, use cases, uh, because they can be the most consistent and, um, are already, you know, um, committing, no pun intended, you know, many of the best practices.

Okay. Um, one of the other things too, and we're gonna go through this 'cause this is actually one of the fun parts of the workshop, is that, you know, if at first you don't succeed, you know, iterate.

Try and try again. That can be frustrating sometimes, certainly. Um, uh, we, we've all been there, where, you know, you, you get so close to getting something that you want and it's not quite there.

But at the same time, this can be a really great way of learning what sorts of prompts work well and what sort of prompts don't work as well. Um, and so, um, for instance, uh, in, in this image, uh, I'll just describe this.

Um, you know, the initial comment said, you know, "Write a JavaScript function that finds the maximum value in an array." And that's pretty broad. And so what the result is, is also fairly broad and, and generic and, and might not work for what you're wanting to do.

But the second prompt, by being more specific, by being more, um, intentional Create a JavaScript function, findMax, that takes an array and returns the string with the maximum length.

Ensure the function works correctly for arrays, um, as, as, um, that are embedded as well as arrays that contain both strings and numbers. That's gonna give us a much better result.

So these are, these are things that, again, being more specific with your, your comments, um, e-either in your code or with your queries to the chat agent, um, it can, can work really well.

And as you find things that work, you know, playing around with things and iterating is, is the best way of doing that. Um, another, another, uh, best practice is providing examples in your prompt to clarify what you want Copilot to do and what you want it to take into consideration.

So you can inside that, that prompt, you can, you can put some, some sample code and, and say, "Hey, consider this, this example data. I want it to work correctly for things like this."

That's something that, that the, um, AI can understand very, very well.

Uh, and, and then again, keeping files open that are relevant to the requirements of your current file, this is great. If you wanna call in other things from your broader code base, you can use the [REDACTED:username] agent.

Uh, but, but keeping those relevant files open, that's going to help, um, a-as well. Um, and, um, again, like, there are still going to be limitations by how much context everything can take in, but this is, this is getting better all the time.

Um, and then, you know, above all else, you know, just go with the flow. Uh, be open to things sometimes working, sometimes things not working, and, and experimenting.

Okay. All this is great. We've got a, you know, quick kind of overview. When can I write code? Well, we can, we can start to do that right now.

But the first thing we wanna kinda talk through is, is getting set up. And so again, this is our-- going to be our main, um, ground zero repo. So this is gh.io/aifair-workshop.

So if you wanna go to that repository now, that would be great.

Now, if you already have GitHub Copilot, um, if you already have access either on your personal account or through your company, that's all you're going to need to do.

But if you don't have GitHub Copilot, uh, we do have a coupon code that will give you access, and that is, um, going to be at this URL. That is actually linked on the repo.

It's one of the very first things linked in the repo, both, uh, as a, a, a physical link as well as a QR code. But if you wanna go ahead and, and scan this QR code, you can activate a coupon.

This will give you a seven-day free trial of GitHub Copilot. If you run into any problems getting this activated, what we did find last time, there are a couple of steps, um, after you enter in your information, um, where you will want to go ahead and, um, make sure you click Apply, I, I think like, like two

or three times. Um, this is what, what that-- it looks like. Basically, you're gonna click on Apply coupon, and then there's going to be another prompt to basically say Activate GitHub Copilot.

So we'll just give people some time here, and if you need to see one of the other screens, um, let me know about that.

And if anybody has any problems getting their coupons redeemed, please, uh, feel free to raise your hands, and we will send people out to do that.

This is that main repo, by the way.

And you just click on this link, which is in the repo. This should take you directly to

the page. I already have Copilot, so I don't need to do this. But, um, where you just need to fill out your information, and then you can go from there.

Give

people some time for that. And the next thing you're going to wanna do, um, um, after you've redeemed your coupon, and again, we'll, we'll, we'll, we'll, uh, make sure that we take time for, for, um, if anybody has any issues to get that set up, is in, again, this, this Copilot hands-on repo, you're gonna wanna go ahead

and, and fork this repo and make your own copy so that if you need to make any changes yourself, you can. But the more important aspect here is that to run this, this workshop, we are going to use a feature called the GitHub Codespaces.

Now, I am curious, how many people in the audience are familiar with GitHub Codespaces?

Way less. Um, okay, cool. So GitHub Codespaces are actually pretty awesome. Um, this is, uh, think about it as a virtual cloud environment. So basically, it is a pre-configured, um, a VM in the cloud that is set up specifically to have, um, certain features, um, that, uh, uh, that you've defined in, in your repository.

So there is a devcontainer.json file, which is basically kind of like a fancy Docker file, which will outlay- These are going to be the, uh, various dependencies and versions of the different things that we have installed specific to this repository.

Um, you can also designate what extensions in Visual Studio Code you wanna have installed, because we're going to be running that either in a, in a web browser instance, or you can open it up in the, the VS Code client as well.

Uh, it also works with, uh, with, with JetBrains, doesn't it? Um, uh, I, I believe, yeah. Um, but we're gonna be using VS Code today. And, um, this is just a really great way of, um, not having to bother with the process of setting up your environments.

Um, it instead can be configured exactly as, as it is in the repo rules. So in this case, um,

I've already forked my repo, so if... to get started, you want to just fork your own copy of the repository.

I've already done this, so I'm not gonna do this a second time. But, um, I... but, but, but I could. And, um, just go ahead and create fork. And once you've done that,

what we're going to do is click on this code button here, and there's a drop-down menu. And you have... you'll, you'll, uh, probably by default see local options. We're not going to do that.

If you wanted to do this locally, you could, but it's actually gonna be faster and, um, um, a, a little bit easier with Codespaces. Um, go ahead and, and click on Create Codespace on main.

And what this is going to do, this is gonna take a few minutes. This is going to create a... my case, this is wanting to open it in Visual Studio Code.

Um, I will actually fake that, um, because that's my editor preferences usually. Um, what it's going to do is it's going to spin up a VM. You could in, in another instance, uh, uh, Dave was talking about this, uh, before, and, and we could do a, a longer and different talk about how you could configure your Codespace

to, uh, have more cores and, and, and more RAM and, and be faster. But for the purpose of this demo, just the default is just fine. Also, with every GitHub account, you get a certain amount of, of free Codespace minutes, so that works great for us in these purposes too.

And what this is doing right now is this is basically Visual Studio Code, but in the browser. And so this is now spun up, um, a, a browser instance of VS Code.

Um, and it is setting up a remote con- um, uh, connection, and it is now building out this Codespace. So it is installing all the various dependencies, um, as, as defined in this dev container file, and, um, it is getting them ready, um, to, to run.

So just for anybody who might be curious, um, 'cause we will actually look at this a little bit later. But this is what that dev container file looks like.

And this is just a, a JSON file, and you can see basically that it is, um, installing, um, has certain, uh, settings set up for VS Code, including extensions for, um, you know, a code spellchecker, um, uh, the, the GitHub-style markdown preview, GitHub Copilot Chat, and GitHub Copilot, um,

as, as well as, uh, using an, an image, um, from, uh, a, a Docker image that, that had, uh, that's configured for, for, for Python, um, 3.11. So

this is now what the Codespace looks like. And so this is going to show how these things work. And what's interesting is it's going ahead and it's, it, it's installing these extensions.

And if I click on these extensions, you can see that right now

nothing is installed. But in a couple of minutes, uh, or hopefully moments, we will start to see our Copilot stuff come in, as well as our files. Yeah, here we go.

So now it, yeah, now it's just going ahead and it's, it's installing all of these extensions that we have access to. If you wanted to open this up in a local instance of VS Code, you could do that.

You would need to go ahead and manually install some of those extensions. That, that's the nice thing about doing it, um, in the, in the browser. And these are all the files that are from our repository.

So this is basically identical to what we were looking at before. Um, and actually,

one thing you might wanna do is... in that main repository that we, that we've been, uh, kind of focused on, at the very bottom, there is a labs document that says a Copilot hands-on lab.

Uh, this was a great tip, uh, that, that, uh, Dave had, and, and it's, um, it's in the documentation, but I'm gonna go ahead and do this here too.

If you wanna open that up in its own tab in your browser, um, and then maybe put it in its own window like, like so,

using, you know, whatever window manager you use. Um, I'm on a Mac, so window management sucks. Um, if you wanna tile it off to the left-hand side of your screen, um, and you can make that bigger or smaller, having this visible throughout the entire lab will be really, really good.

So that, that's, that's, that's one pro tip here. Um...

What did I lose? Okay. Again, I'm on a Mac, so windows man- wi-window management sucks. Um... [laughs]

I know, right? I know. You, we're finally gonna get some, some tiling management, hopefully. It's, it's, uh, it's ridiculous. Okay, and then there's this. Here we go. Great. Okay.

So I've now got these things configured that I have. This is my, um, uh, Codespace, and then this is my, my hands-on lab. Um, and at this point-

Um, on the bottom lower corner of your Codespace is this, uh, Copilot, um, uh, uh, icon, and you can see that the status is ready and that Copilot Chat has been, um, enabled.

Now, um, the chat window is here. This is the, the, the chat window, and in this way, I can either talk directly to the code base. I can also use-- there's a, an agents feature where I can talk directly to, for instance, I can, um, if, if I have a GitHub Enterprise account, I can use [REDACTED:username], and

I can ask questions about my, my GitHub account. These are primarily enterprise-related features. [REDACTED:username] is great. This will show you how to do things in your terminal. It's really, really good for FFmpeg commands and other things that you don't wanna memorize.

Um, and [REDACTED:username] will ask you questions in general about VS Code. It's also a really good way of kind of managing settings. And then [REDACTED:username], this is gonna be asking questions in general about the workspace that we have open.

So if you wanted to ask a more general question or, or to continue to add context from what you're working on, that's an agent that you can use using the chat extension.

So let me go back here for a second.

I'm just gonna put this back on screen for a minute.

These are the, the, the main links and resources. So the first thing is the Copilot coupon. Then we have the, the main repo where everything is taking place, and then we have the lab's, uh, README.

So these, these are kind of the, the main three things that we'll be working on. And if anybody has any, um, uh, problems getting access to anything, again, please raise your hand, and we will do our best to assist you.

Oh, yes.

Uh, I have a question on a feature.

Sure.

Yeah. Um, so a feature I want, um, a lot of times I do something, um, yeah.

What is the equivalent of the Control plus Enter to see the multiple, kind of, suggestions for the selected node?

Um, uh, what, what... Do, do you know, Harald? What, what, what's, what's the shortcut, um, on, on macOS to see the, the multiple, uh, the various code suggestions?

Command.

Yeah, I think it's just-- That's not working for you?

That is Control. So it's Control.

Oh, it's not. I didn't know.

It is.

Oh.

Thank you so much. That's nice.

All right. I lost connection to my Codespace because the demo gods are with me today, so this is reloading things. That's okay.

That's the, that's the one pratfall of using the, the cloud code environments is that sometimes they can, uh, run afoul. But in general, they work pretty well. So again, um, I've got my, my lab's, uh, hands-on stuff here, and we can just-- Once you've got this set up, we can go through the first lab.

Um, and this is a fairly, uh, basic one, so if, if this is something that you, um, uh, are still setting up, don't, don't worry about that. So the first thing that we're going to be doing

is creating a new file, in this case, an index.js file. So yes, we are using JavaScript in this example. Don't be afraid.

All right. Now, you will notice that it says I can press,

uh, in, in my case, Command + I, and I, I think that it's Control + I on Windows, where I can ask, um, a Copilot for something, or I can type a slash command.

Now, these slash commands are, um, ways that you can, uh, basically, um, I guess, simplify, um, certain operations with Copilot. So for instance, doing /doc will add a documentation comment around a symbol so that you can have a, you know, notice to go, go back and document your code more.

Um, /explain is actually really great. This is gonna explain how your code, um, in the active editor works. Um, and it's pretty good. There are some hallucinations, a-a-as there are with all LLMs, but it's, it's, um, pretty good, and it's, it's improved quite a lot even in, in just the last few months.

Um, that's one thing that I didn't mention earlier. Um, we are updating our, our Copilot model fairly frequently, and, and we're, you know, rebasing on, uh, you know, um, the

various versions of, of, uh, uh, GPT that, that come out from, from OpenAI all the time. But, uh, we are also then fine-tuning on top of that. And so the Copilot that i-if you first tried GitHub Copilot- A year ago.

You're going to get a different experience now, not just from the tooling perspective, but, but also in terms of the results because the models are getting better all the time and, and, and we're actively committed to, uh, improving those models all the time.

Um, slash fix will help you propose a fix, um, i- if there's a problem i- in your code. Um, a fix test failure will propose a fix for a, a failing test because writing tests is one of the best things of, of using a coding assistant.

And then again, slash test will help you generate unit tests for your selected code block. So

those are those options right there. All right. I've created this index.js file that I've got open.

Now, I just need to add a comment in my code.

And if I can spell correctly with one hand. Um, and, and if I can spell function correctly, that would be even better. Although, you will notice that, like, it actually, it picks up on typos fairly well.

Okay. So have this. By hitting Enter, the first thing that it's giving me is something,

something pretty minor. Um, and, and it is very similar to what, what, what our example says. Now, I can hit Tab, and I can accept this. Um, and, and this...

Uh, by the way, this, this text right here, um, see if I can zoom in on this more.

No, it is not letting me zoom while I'm in full screen. Great. Love you, um, Apple. Okay. Um, [laughs]

when you see this gray text here, this is what's known as ghost text, and, um, this is something that, uh, that, that Harald can actually talk more about. If you wanna maybe explain the different types of, of text and, and what other people see when they're using Copilot.

Yeah. Um, so I think, yeah, we, we start with completions, and that's the in the flow, you don't even think about it mode of Copilot. It always works, and when you get really used to it, you kind of ignore it when you're in the flow, when you're coding, when you know what you want.

And then once you want Copilot to kick in, you just wait a bit. It kicks in. You might even try different suggestions. You kind of flip through. Maybe you accept it word by word, and let's see what, how else it continues.

But it's really, you don't even think about it. And you notice then when you sit in the airplane and you stare at your screen for a minute, that you're in airplane mode and Copilot doesn't give you anything.

So that's when you know you build a habit. Then the other one is, uh, further next is inline chat, and that's where you, you can open up a little natural language input over your code, and that's where you can apply AI directly to your code.

And that's, in ChatGPT, you keep kind of having long-winded conversations about code, and that's where inline chat is much more powerful in giving a way, uh, quickly iterate on code to generate and edit both code.

And then lastly, chat panel is kind of the OG idea of ChatGPT in your VS Code, an editor chatting with context, being more in the exploration mode, where you wanna have conversations, where you wanna treat it like an A, uh, like an actual AI pair programmer which can challenge you, which, which can critique your code, where you

can go a little bit more back and forth and explore a solution. So these are kind of the three modes and when you wanna use them.

Awesome. Thank you, Harald. You're the best.

Follow-up.

Yeah, yeah, sure.

Um, I was just curious to know if there's a...

Thank you. I was just curious to know if there is a difference, um, you know, between the ghost text it generated here, um, so just doing it, you know, inline in the editor, versus if I was to have that function and then use the Control + I to say, "Write me the rest of this function."

Like, is there a difference in how the context is being provided to the underlying model? Is there any, like, reason we should use comments to get it to generate versus, uh, Control + I or chat in terms of-

Yeah

... context?

My, my personal take is you will see when code was generated with Copilot ghost text 'cause it has all these not very purposeful comments written in that very much describe the code below, which are not typical code comments.

You wanna describe, like, your reasoning and your thinking behind it, but that, that's not how you prompt craft with GitHub Copilot. So inline chat allows you to pull that prompt crafting into the inline chat and just get the code out and be more specific and elaborate in how you can describe it in that inline chat prompt.

So you, you're less iterating on the comment, but you iterate in a natural language input, which is sometimes more intuitive. So you will find if you, if you like writing long-winded comments and tweak on the comments and then hit Enter again and see what Copilot writes, that's basically a much faster, more direct flow with inline chat.

Yeah. That makes a heap of sense from a user, um, experience perspective. Just also keen to understand, is there a difference in terms of how that is being provided to the model between the two different ways of doing that?

Yeah, definitely. Uh, the, the c- chat, the ghost text is more grounded in the neighboring tabs. It has a much smaller context window because it needs to write it much quicker.

And then inline chat has way more freedom to include other context, dependency, documentation. So depending on which commands you're executing, it will do more work upfront to get context and more context.

Awesome. Thank you.

Yeah.

And there's a question in the back too.

Yeah, that was the question.

Okay.

Yeah. Fantastic.

Uh, no, it's just for me the, the, the inline one, uh, also kind of allows for

Awesome. Okay. And actually, just to, to show you here, there are these sparkles that come up, um, uh, where you will see certain things, and you can actually choose, uh, options to, like, fix using Copilot or explain using Copilot.

In this place, I'm just gonna show, uh, explaining. And this is just going to say, "Okay, this is the references using," and this is just, um-

Giving me, uh, a- an explanation of the nonexistent code that we basically have already kind of created at this point. So

going further through the, the, the lab, um, this is what it's going to generate now. Now, when you do create, uh, when you do get your code suggestion,

if you are not happy with, with what you're getting, there is...

You will sometimes be able to, to, um, uh, get other options, um, for, for other code suggestions. Um, but, but just kind of going through this, um, th- this, uh...

For instance, let me go on. Okay. So when I, when I press Control + Enter, and it is Control on both Mac and Windows, this is going to give me a list of suggestions here.

And so I have seven... I have, wow, I have eight different suggestions that all could be very, very different because, again, I gave it a really, really generic prompt, which goes to one of our first lessons we were kind of talking about.

Be specific. Be specific with what, what you want, uh, to achieve because I have eight different suggestions that all, all vary in, in what they're wanting to do. But this is one way that you can actually choose different suggestions.

So in this case, if I wanted to accept one of these suggestions, I could do that, and it's going to put those lines in place. Now, we are going to go ahead and, um,

not accept any of these. Instead, what I'm going to do is I'm going to...

Sorry. Typing with one hand is difficult. And you can see the ghost text coming up as I'm typing things out, so it's actually going ahead and putting further things here.

I don't actually want all of this, but I can just have this aspect here, and this is going to go ahead and p- potentially complete this, this code for me.

And if I wanted to select that, I just press the, the Tab key, and that's where this will come. And so basically, that's-- this is just our, our, our first lab.

This is just going through how this works. Um,

Harald, if you wanted to come up again and just you go, go through lab two, which we... I, I think I already showed off th- the bulk of it, but this might be, might be useful for folks.

Okay.

Harald, I did adjust it, so it should work now. [clears throat]

Okay, so no problem. Good. Let's go. Lab two. So, um, I think I showed it before. So once you're in ghost text mode, one good way, I just showed over here, is to hover the ghost text.

Everybody make some ghost text and hover it. [laughs]

That, that little widget gives you the right keyboard shortcuts and a little three dot menu on the end.

I'm gonna demo it here. This is why you're so... It's hard to type. [laughs]

I wish I had larger hands. Okay. So the classic is, uh, single line completions, and this, this, uh, especially in function bodies, Copilot will go into multi-line, which are easier to hover to.

In the top right, you now see the, the little widget which has one slash three and an accept, an accept word. So remember the accept word shortcut. That's a good keyboard shortcut to impress into your brain 'cause that lets you this...

lets you get out of this mode where you have to accept a whole function body that Copilot hallucinated for you, but start with the initial one that has the highest confidence.

We're like, "Yeah, that's the part I want." And then the rest I can work out with Copilot and fill in the rest as I figure out what I actually want.

But that's, that's one way. So hitting the Command + X or Command + Right, uh, that's one way. If you wanna do the c- full line, there's also... Come on.

I will do.

Yeah. It's so far.

What is this? Why is this so far away? Okay, so accept line is also here. Uh, if you wanna apply a shortcut to that, it's VS Code, so go, go, go ahead.

And then, but the other one is the open completions panel, which gives you this, this idea of more suggestions. Um, especially in multi-line, there's a lot more freedom for the AI to explore how it could solve this problem that it thinks you're having.

So these are usually a good way to understand your options.

And anything else missing? Then we have inline chat.

So the other way you can no- now solve this,

I can just take this out. So let's do a...

Just delete this, and then write. That's where I mentioned in, um, the panel, inline chat versus panel chat. Write a

URL parser function. And that's the mode where inline chat is used to generate code. Now, you don't start with a function body. You just give it an idea of what you wanna get out of it, and you just get a function that will parse the thing.

And actually, if I, I did this before with Copilot completions, and it got to the same conclusion. So you see how you can get to the same end result with different paths.

I could also give feedback now. Maybe this way, oh, it generated an A element. Maybe I wanna use a library for that. So you make sure you use that follow-up field to tweak it.

Don't just accept the first suggestion, as with all AIs, they can get things wrong, so make su- make sure you keep iterating.

Then function-wise, um, now when I accept this,

maybe I make a mistake. Um, classic mistake, just typing parse

system. So you can go every time if you have a linting error, and those can come from extensions. Those are not just built-in VS Code things. If you have X, for example, you also can get accessibility squiggles.

You can go into f- quick fix, and now you can see... Actually, for this one not because it's a, it's a, t-

uh, code spell one. I think there's so much, too much linting stuff in this project. I only get code spell errors. Okay, let's do it the other way. If you have code you wanna fix, you can do the thing I just showed you in the hover, or you can just do right click.

How do you right click here? Let's see. Okay.

You can go into here and then modify using Copilot. That's where you also open inline chat and just hit, hit fix.

And if I actually do insert the mistake, which I think I have, with parses, it will find it. Fix will automatically look at error messages. It will look at potential issues with the code, and it's to generally prompt it to fix any other issues it finds.

So in this case, even though it wasn't a, a general actual issue, it found that parses is misspelled, and it gives me the change. If you wanna see a better view in inline chat to see the change, you can also toggle changes down here and see the actual line versus line comparison.

This is just optimized right now for space. That's what makes inline chat very, uh, compact and easy to use in, in all kind of window setups. So accept this, and that's the quickest way to get rid of squiggle lines with AI.

I think this concludes lab two. Should I just move on? [laughs]

Okay. Going with lab three is explain. Again, same, same thing, just open inline chat

and do slash explain. So it's one of the many commands we provide. Oftentimes with AI, you end up in a very prompt heavy flow where you keep describing the same thing.

Please explain this code to me, or please explain what this code does. So these shortcuts allow you to not be overly prescriptive for very common tasks like fixing bugs and explaining code.

So slash explain, in this case, will not just look at the current code, but will also look at the dependencies you're using, the symbol definitions, the type definitions, the documentation, and all, and it's all over two VS Code and Copilot chat to make the best sense of it.

In this case, now we're using this tiny view to just give you an overview of the code and how it works, like how do I get a URL out of a link element in this case.

But you can also now open this up in the chat panel on the left to give it some more breathing room and make it easier to read.

What's important, all these answers are also linked nicely, so we do a lot of effort in making these, this code in any explanations really shine and easy to interact with.

So you can easily navigate and click around in these answers as well. That's a recent improvement that landed. If you, if you actually generate code in the side panel, it will also have linked elements and have IntelliSense, and you get all the benefits of getting really, really readable code.

There's explanations. If you wanna have a custom explanation, though, you can still do that. So if you wanna have a command I slash explain

classic prompting like I am [REDACTED:age]. It's not really doing the [REDACTED:age] thing.

I'm a very smart [REDACTED:age]-year-old, so [laughs]

You can also ask another language, right?

You can ask it like, yes. Uh, if you wanna-- Yes, I could. If you wanna actually switch that, if you look for Copilot settings, uh, switch it to different languages.

You can actually switch the language of Copilot. So the locale, if you go into your settings in VS Code, there's a locale override locale, and you can switch it to different locale.

So by default, Copilot will be using a language that you pick it in. You can mix up languages. I, my original language is German. I also speak Spanish and French, so when I don't know a word with-- when I speak to my wife, we just switch languages.

Copilot will be as well [laughs] understanding you if you just high level describe it. So in some cases, it's good, like, um, later on, we show you add workspace. It's good to be hitting the right words of concepts that you expect in your code base.

So if you know the word, make, make sure. If you know reference, be, be specific. But otherwise, it's interesting also to be vague and add some ambiguity to let Copilot figure out and give you some ideas on how you can solve a problem.

Okay. So this should get you through the inline chat parts and

into the chat panel, which we already went to. Okay. Chat panel trick number one, um, remember this button up here to open a new chat.

Um, same shortcut is for clearing a terminal. It's c-control L. Very important. Uh, very fun, quick way to start a new conversation. If, yeah.

Because Copilot will look at your history every time you answer, just like in ChatGPT or in beginnings of Bing search AI, where it fell in love with reporters after [REDACTED:age] back and forth conversation, was stuck in a very romantic mode.

Copilot can also s- can stuck, uh, can get stuck on concepts and anything you talk, discussed before. So if you start a new conversation,

reflect that, uh, by actually opening a new chat. You can still switch back and forth in the history, but make sure you begin new conversations actually in a new conversation.

Uh, but also about history and conversations in the inline or the one in between panel, the one with the AI.

Inline chat does not have history right now. It, it has-- If-- Remember that you can, um... Just close this.

You can go up and down to come, to get to old history items, so use that.

But I thought we, we do store these in history now, so I have to, I have to get back to you on that. [laughs] I know, I know they end up somewhere.

But it's all locally kept, so none of these things are synchronized to GitHub. It's all just kept in a place where VS Code keeps its data. It's in your local profile, uh, not anywhere online.

So, uh, quick trick here. If you wanna see everything that, that Copilot can do, it's /help, and that's providing you anytime you forget which commands and what they do and why there are so many, um, that that's the best way.

So that's, that's giving you all, like, learning commands to, for common things like /fix, /explain. Play around with the more edge case-y ones like /new, which allows you to bootstrap a whole new project.

Uh, but it's also the context variables. Uh, but all of these are auto, also autocompleted. If you, as soon as you hit slash or hash, you will see those as well as you play around.

There we go.

Yeah, I was gonna say, I'm not sure where the microphone is.

Okay. Yeah.

Cool.

You had-- Oh, he stepped out. There was a question about how to use the new notebook command there. And so in the discussions on the DevOps thirty version of the repo, I added a little discussion that says, "How do you use that command?"

And it points to, you have to feed it some more context. I'm not a Jupyter Notebooks guy, but it's, uh, it's like, you know, using this data set, I wanna generate this kind of a thing or whatever.

So yeah, some of those commands you'll have to get a little bit familiar with exactly how to follow up that command. What do you need to feed it-

Yeah

... and things like that. So they can be very powerful once you know how to use them.

Yeah.

Who's, who's using notebooks in VS Code? Awesome.

Yeah, it's definitely, if you do data science, uh, not using notebooks, like, it's a great place to move from data analysis to actually writing code and shipping,

shipping it. So, and I use it tomorrow in my demo as well.

Unintended [laughs] product placement here. Okay, uh, generate tests. Think nothing more to add here, just play around with it. It's a great way. Again, it shows off ghost text and /tests.

If you use inline chat, for example, another case where inline chat does a bit more work, it actually tries to detect which testing framework you're using, which folder they should go in.

Um, but it also, if you use ghost text and you have the file open implementation that you're trying to test, and you just start writing tests, it also gives you this magical experience of just understanding the implementation and writing tests for it.

So depending on which flow you like most, um, those are interesting places to explore it. So hack away and ask questions.

Oh, yeah, hit the button. No, I was just gonna say at this point, uh, you can just kinda go through the labs and, and play around. And if you, if you have any questions, raise your hand.

Also, use the discussions. Let me go back to that slide. Um, thank you so much to Harald. Um,

go back to the slide where, uh, all the links are. Um, we'll be happy to help you out. Please continue working on your labs if you wanna do that.

But, um, I just wanted to throw this out there. If anybody has any kind of general Copilot questions, uh, that you wanna ask us, especially Harald, frankly, because he's, [laughs] he actually works on, on, uh, the, the, the VS Code team and, and works on a lot of this stuff.

Um, this is a great opportunity. So if anybody has any questions, um, out there, we'd love to

see if we can answer them.

Questions have to be three point [REDACTED:age]. Everything right now is three point [REDACTED:age].

You can ask it.

Ask it.

Yeah.

Okay. So, so the question was, what, what model are we using?

Oh, that was my favorite question.

Yes.

It's my favorite question. I just closed the issue on GPT four Turbo. Um, it's no public announcement, but I closed the issue on GPT four Turbo. It's rolled out.

So you can ask, actually, in the chat panel, you can ask it which model it's using. And if you're on the latest version,

if not, I'll find you, um, [laughs] it will say GPT four Turbo because I prompted it so.

Four Turbo.

See? If you tell it GPT four Turbo, it's using four Turbo. If you tell it to use GPT [REDACTED:age], it will also tell you that it's using GPT [REDACTED:age], so.

But it's actually-- [laughs] So we rolled out, uh, f-four O's and, and it works as well.

Uh, inline chat is still 3.5 because 4 is too slow so far.

So, so that, so that, so that's interesting. Maybe talk more about that. So-

Yes

... so 4, uh, even though, even, even Turbo, even though you just closed the issue on Turbo, 4 is still too slow for inline chat.

Yeah. We- we're-- So we're constantly running this multi-model flow, um, especially because we, we wanna al- always balance the, the, uh, performance developer experience where it can stay in the flow.

And that's why for completions, we're using 3.5, a very smar- very small context window to stay under these 250 milliseconds instant ghost, uh, text popping up for most users, so on average.

And then for inline chat, 3.5, uh, when we ran experiments, when we ran, uh, offline evals and the whole systems we have in place to constantly assess new models, we actually noticed that there's only a slight lift in quality and only in some languages for inline chat going to GPT-4.

But then when we ran an ap- experiment, a lot of people churned out because their time to first token is still a lot slower. So we're always taking this approach of balancing this performance and quality aspect and what, what, what provides the best experience in, in the right job.

So and that's why, yeah, so every panel channel, panel chat question you ask right now gets-- did get GPT-4, now gets GPT or Turbo. And inline chat, just for that performance aspect, still uses 3.5.

Very cool. All right. Now, now when is, uh, GPT-4.0 coming?

It's coming. [laughs] [laughs]

I had to ask.

Yeah. [laughs] Follow the issue. I'll close it.

With, um, with all of the work that's being done by Microsoft with, and many others besides, with small models like Phi-3, et cetera, are you looking at testing those and implementing them?

Yes, we're testing those. Yeah.

Interesting.

Uh, there's actually, if you look at the Phi-3 cookbook on GitHub, there's a chat extension sample for VS Code to use Phi-3 locally in chat.

Awesome. Out, out of interest, are you able to share what sorts of things you look at when you test new models within the GitHub Copilot product? Like what metrics you might look at?

Ooh. The, the, the behind the curtain. So we have-- So most of our offline evals are code-based. So a few things, slash fix, uh, slash docs. And we have a smaller test set that runs generally on each change, code change, where we test specific patterns if they improve or, uh, regress.

And that's mostly based on issues we've seen in the past. Like, oh, it didn't get, uh, this pattern right, or it didn't look at specific files. So we're trying to adjust, assess the general competence and what we expected.

And then there's larger offline evals where we run it on across different repos and try to understand how, how well these slash fix and slash docs work. So those, these are not public benchmarks, but they're trying to assess basically it against open source code that we can get to run on GitHub.

So if you have a repo on GitHub, make sure it run, the test runs. [laughs] Yeah. So yeah, that, that, that's basically gives the baseline. They, they never pass 100%.

There's always, like we're trying to get the pass rate up, but it's typical offline eval of we're trying to get better over time. And initially, a lot of the big model updates, they don't necessarily 10X those metrics.

There, there's always some languages get better, some languages get worse. So it's, it's really-- And they always require prompt changes. So don't, don't run after the latest model just because somebody told you so.

There's always the nuance of actually optimizing for the models and then testing out each model separately.

Uh, I didn't quite catch that. Didn't quite catch that. Did you mean that we can test the Phi model locally? Uh, did I understood that right?

Uh, check, search GitHub for the Phi-3 cookbook, and there's an example there too.

I'm gonna put it in the, in the description.

Yeah. Okay. Thank you.

All right.

So for background, uh, VS Code has an, has extension APIs. Many, many thereof. So all the cool extensions you're running are in VS Code are using these extension APIs to provide the functionality.

We have extension APIs for Copilot Chat. You can actually add your own participant, and you can actually provide your own models in the chat as well. So these, these are two, uh, extensions.

There's also a blog post, um, that just came out yesterday.

Yeah.

Uh, I think that will, that, that you can check out on the VS Code blog that talks more about extensions. So if you wanna play around, uh, a lot of pe- companies do this internally for their own developers, just bring in their own developer experience and knowledge into Copilot Chat and some custom flows.

And other companies like Stripe and Postgres and o- other projects are bringing these chat participants via extensions into Copilot Chat for some custom workflows for all their developers that they're serving.

But that kinda allows you to plug into the existing, I don't know, experience. The-

Both. Both. Yeah. Yeah

... is it possible-

Yeah

... or will it be possible to replace the connection to whatever GPT model would be used at the time to be able to use the Copilot at the companies which currently do not allow it?

Uh, because that would mean sharing your code as you go with an external provider.

Currently not. So that's, that's not a, not a-

Yeah, I, I know it currently not-

... replacement of the underlying model

... but is it-

But, but the P- Phi-3 cookbook shows you how to do it in a more sandboxed way to replace parts of the Copilot module.

Yeah. I, I understand.

Yeah.

But, uh, d- is there any chance that it's coming anytime in the future or something like that? Like a-

It's on the list of things we're looking into, yeah.

Ah.

So we're, we're, we're looking at models.

All right. Thank you. I mean, I actually have a few more, but I-

Yeah. [laughs]

Anybody has any questions?

Uh, so the next one is, is there any intended use difference between the Control-I inline mode and the, uh, sorry, the Command-I and Command-Shift-I modes?

Between inline chat and-

Yes, and the inline chat-

Yeah. There's no such thing

... just like the standard Command-I.

Yeah.

Right? And then we also have Command-Shift-I, right?

Oh, quick chat.

Yes.

Yeah. Uh, if you haven't tried it yet, Con- Control-A is, uh, quick chat. That's-- The idea is, so we're exploring different just form factors for chat, and that's more of a quick question overlay.

So that's kind of the idea. You don't want to go into panel chat, especially on a small viewport.

Yeah. All right, all right.

So it's mostly a UX pr- preference.

But this will have the conversation, uh, the history conversation then.

Yeah.

All right.

Yeah.

And does it also have a new chat then that you-

You would just close it. You would just... Yeah.

Oh, all right.

Yeah.

So it holds the conversation as long as it-

Right

... stays active and open.

And Control-L works, works, works as well.

All right.

You can just empty it.

Got it. Perfect.

Yeah.

Uh-

And let me, let me, let me just, uh, uh, ask that question so everybody can hear. Um, the, the, the, the question was basically, um, is there a way to take advantage of, uh, I guess, like, local documentation, um, and, and agents that might take, might, might exist in, in, in a code base that might be more

updated than, um, what the, what the model itself is. Is that getting close?

Yes, but not local documentation, but rather the, the libraries.

For-- Right. So, so for libraries. So it's not, not locally, but for other libraries, but for things that, that just the model hasn't been updated for because things are changing all the time.

Yeah. So Copilot for Enterprise has knowledge bases. Um, if you do some links in the training in the end to Copilot for Enterprise and some of that documentation. So knowledge bases allow you to import a repository with markdown as, as a grounding, and then reference that in your question, especially on github.com, but also in the [REDACTED:username] agent

in VS Code. And we're trying to make that more accessible and naturally to apply to code. But that's one way, um, that you could bring in external documentation, just have it, have it indexed, have it referenced.

Then you curate it in these knowledge bases as something you can reference, like using our LLM stack, and then you, you reference the combination of different projects that you're depending on, and you can update them a- a- as you, as needed.

Uh, there's more work there, I think, to bring knowledge bases to a more usable and easier-to-update flow. So that's something we're also looking at.

And so do you envision then that if people keep doing this, we call them agents, right? So the, the Stripe and the Octopus and stuff like that, that you can add that.

Yeah.

Uh, if people keep doing them, would you imagine that the Copilot would be able to just automatically understand that, right, if I'm asking about something connected to Octopus, and I maybe don't know the answer, I can just kind of reference that from this agent?

Yeah.

And so the Copilot would ask the agent, and it gets the answer by-

So the question is, do you... Uh, I guess two questions. So one is, do, is there some knowledge retrieval we can do with these chat participants? Uh, chat participants can provide context variables.

So if there is specific context that those participants want to provide, like their API documentation or more dynamic things like which actual databases are used in your, in your product and what is their schema, they can be exposed as context variables, so you can combine them with other context.

And we actually, yeah, we're just looking into more automatic inference, how to get this context in, so you don't have to know about-

Rather not providing the context, but rather like, uh, agent delegation, I would say. So like the GitHub Copilot would work as an orchestrator in a way-

Yeah

... where, um, it can delegate specific questions to specific agents, which then can hold like specific information on that domain or that library or database.

Yeah. So-

So, so you're basically saying if you asked a question and, and Copilot didn't know it, but it was about something that you had an extension installed with or an agent installed with, it could automatically then send that to, to, to the agent.

Yeah.

Yeah. That's, that's actually on the exploration for, within the next six months. So we're looking... 'Cause we, we see when people discover extensions, it's like, "Oh, this is amazing.

I want to use this every day," and then they keep forgetting about it, or they, uh, they never discovered it upfront, so that's a big problem we saw in our user testing.

So the automatic inference is a big part of just Copilot being aware of what you have installed, uh, what you're working on, and then calling the extensions as needed.

So that's coming.

Awesome. Well, thank you so much, Harald, for this impromptu Q&A that I just, like, threw at you at the last minute. We really appreciate that. No, no, no, no, no, no, no, you were fantastic.

I just... This was an idea that, that Dave and I had. We were like, "Well, while we have, you know, member of the-

Of course. [laughs]

... member of product team."

Uh, Harald mentioned the blog post from Visual Studio Code that I didn't even realize was out yesterday. So

on the main repo link, there's a github-copilot-resources.md file, and I already had a reference to the Copilot extensions blog post that came out in conjunction with Microsoft Build. So in that section, I said, "And see also this Visual Studio Code."

So we're, you know, we're being as dynamic as we can here. Um,

there you go. Yeah. So that blog post is now, you don't have to remember this URL, just the, the repo your, or the DaveOps resource-- Or sorry, the DaveOps version of the GitHub Copilot, uh, lab.

The, check out the resources file there. Also, check out the discussions. I wasn't able to find what Harald was referring to with the cookbook 5.3 or whatever, but we can throw Oh, awesome.

Awesome. So yeah, when you go to those discussions, you know, we, we have those links and, and things there. We'll even-- I'll keep an eye on those, uh, discussions for a few days, so if something else comes up, feel free to, uh, throw a question or a comment out there.

And since we are-- we got about a little over twenty minutes left here, I will put in a plug too. There's a couple of survey questions there. Please let us know what you thought about this lab.

Please let us know what you thought about GitHub Copilot in general. And, you know, add comments on either one of those if you, uh, would like to.

Anybody else have any other questions or anything? [chuckles]

Is GitHub Copilot Workspace going to replace Copilot Chat, or

does it have any other purpose, uh-

Yeah, I think from my perspective, yeah, I'll let Harald talk about it, but I think there's, you know, a purpose for Copilot Workspace and a purpose for Copilot Chat and, and everything.

I'll let Harald address it.

It's Copilot, the whole of things.

Yes.

So who has seen Copilot Workspace? Okay. Let me describe it in break stroke, [chuckles] great stroke. So Copilot Workspace is a standalone experience where you can start from a repository or a PR or other places.

There's great demos, great videos out there. There's an early adopter audience already playing around and getting really excited about these flows. But you can start with a task. It breaks it down into a plan, and it allows you to make cross-repo, uh, cross-file edits and implement features, fix bugs that are more complicated.

But it's a, it's a great end-to-end flow that keeps the developer in control at every step and allows you to give feedback and correct the plan and correct the plan items and stay in the loop as the AI proposes changes.

The outcome is that you end up with a diff, and the diff can even run the actions in the repository. You have a terminal where you can run through your build step and have other ways.

So there's a lot of, a lot of pieces built in that suddenly look like an editor. So my, my hopes this is eventually something that if you ask a more complicated question in chat, it will just use a workspace-like flow to apply these edits.

But there's also other explorations that we're applying. How can this look like in PR reviews? What's the best workspace flow for the many things developers hit in a day-to-day?

How can AI help with reviewing a PR? So all of these things are where a more specialized AI breaks down a task into multiple steps and keeping you in the loop and in control.

So I don't think it's a replacement. It's a, it's a necessary flow. It's something you can already do in GitHub Copilot Chat. Just start with asking it about a plan and then work with Copilot through a plan.

So with proper prompt crafting, you can get pretty close to that experience and stay in control. I think that's, that's the main one there.

In VC, in VS Code. Do I use that?

Yeah, yeah.

Yeah.

So make sure everybody can hear.

All right, perfect. I'll, I'll-

I'll get my stuff.

Hello. Super. [chuckles] Thanks. All right, so the question was, um, Copilot Enterprise has a couple of really cool features such as PR summaries or knowledge bases. I'm keen to understand in terms of those features living in VS or, like, in the code editor.

So, so, like- Yeah ... I'm doing a PR. I'd like to immediately summarize what the PR is about. Is there some sort of outlook on what that's gonna look like?

So you-- there is a way, um... It's a, it's a different experience, but there is a way to summarize, uh, PRs in VS Code right now. So there is a way to do that, that, that is separate from the, the, the GitHub Enterprise feature.

But this is actually, I think, and, and you can talk more about this. This is something we're, we're trying to kind of balance, the, the two experiences between, you know, how things work, you know, kind of on github.com and then the, the way that people are using their editor.

Um, if you wanna say more about that process.

Some, some hot takes. No. [chuckles] Um, so I think in the beginning, you saw definitely more Copilot experience sprouting up under the, like, Copilot X moment that happened at Universe.

So just people trying out, like, what, what does AI mean in developer flow? So PR, uh, descriptions went out there, and then this new tier, uh, SKU for, for Copilot for Enterprise.

So I think a lot of it's like, w-what is a value add that we can bring to enterprises that work for if you have a thousand repos and team to manage two thousand developers, what are the different use cases that are not as simplistic, um, of, like, a typical day in a developer working on a project?

So there, there's a lot of that thinking right now happening, like how to best separate those. I think a lot of times we, we are focusing on bringing everything that's happening on github.com, making sure it can shift left, uh, into the developer experience in the editor as well.

So, uh, as you can see, we already have, like, in Co-- VS Code, you already get the little mag-magical AI buttons that can write you a commit message, that can write you a simple PR description.

But if you look at PR descriptions on GitHub, they go to way more lengths of looking at more files. So as you go into CE, those features just become more powerful and more grounded and more suited to the, the, the needs of Enterprise.

So I think that's, that's the best way to think about those. Um, and yes, there are some features that are in, locked in CE right now because they're still-- they need more Enterprise feedback, and they, they need to scale to Enterprise needs.

Um, but otherwise, yeah, there's definitely shift, shift left of these features happening so they become available in the editor as we figure out how to best provide them in the editor.

But no, so if you haven't tried it out in the Codespace, you see the PR extension is automatically installed in the Codespace. So you can manage your issues, your PRs, if you can create PRs, so that's also what, what you can do in Codespaces.

Thank you. [outro music]