Piloting agents in GitHub Copilot

[upbeat music] So, uh, a couple of real quick things for, uh, those who are just getting settled in or just roaming in.

Um, first of all, if you're sitting in the back and hoping for a seat, um, it does look like we are, um, completely, um, full up. I can move my stuff here.

We'll have a seat here, and I think that might be it. Now, having said that, uh, we are going to be... And I wanna make sure that I'm clear about this, so if you're working on something else, um, now is not the time to multitask, um, but instead, uh, pay attention to the, uh, person that's babbling up

in front of the room. Um, uh, we are going to be running the exact same lab, I'm gonna say that one more time for effect, but we are going to be running the exact same lab this afternoon at 3:30.

So even though that 3:30 lab has a different title, a different abstract, I'm here to tell you it is the exact same lab. How do I know that? Because I'm going to be the one leading it. [laughs]

So kind of a little bit of authority there. So, um, do keep that, uh, that in mind. So if you're hanging out in the back really wanting to do this, check back this room, 3:30.

You'll be able to do the exact same thing. Um, second of all, uh, we are running around and getting everybody added into a particular organization. That organization is gonna give you access to GitHub Copilot.

Now, uh, when you get added into an organization in GitHub, you do need to accept that invitation. So, um, please go in, check your email that's associated with your GitHub account, and accept that invitation.

So now is the time to multitask and go ahead and take a look at that. Um, and while you're doing that, I'm going to make the announcement one more time for those in the back of the room.

If you wanna do this lab, come on back at 3:30. We're gonna be doing the exact same lab at 3:30. Okay. And I'll be back in just a minute.

Where would we look at that, Alex? Um, in your email, uh, that you have associated with your GitHub account.

Cool. All right. So here's what we're gonna do.

Oh, I can actually take my coat off.

So there. You have one trigger incident on impact OT. Yeah, if we could get all devices silent, vibrate. If you get a phone call, more than welcome to take it up to- You're more than welcome to take that phone call behind, outside those, those doors there.

Um, cool. So while we are getting everything, um, situated, um, here's what I'm gonna do, is I'm going to, there we go, um, start talking through this little thing called GitHub Copilot, and then, uh, begin to introduce the lab and then get you turned over to the first exercise.

Basically, what's gonna wind up happening is I'll do a little bit of babbling, and then you'll do a little bit of work, and then I'll do a little bit of more babbling, and then lather, rinse, repeat until we have, uh, run out of time here.

We have 73 minutes. Should be actually still able to get through the bulk of the lab, or at the very least, we'll be able to get through the cool parts of it.

Uh, we might, like, skip something just so we can make sure that we can get to, um, uh, to the end. But we'll explore and we'll play with all of that as we, uh, as we go here.

So without any further ado, let's talk about this little thing called GitHub Copilot. If you're not already familiar with GitHub Copilot, uh, GitHub Copilot has been given this tag of your AI pair programmer.

Now, not only is that wonderful marketing, 'cause it is kind of wonderful marketing, um, it's actually, I think, honestly, the best way to describe and to think about GitHub Copilot.

That just as I'm working with a pair programmer, I'm gonna ask them to perform different tasks, I'm gonna ask them to, uh, to do different things, and we're gonna work together, we're going to collaborate to build out a solution to solve problems.

I'm gonna do that exact same thing when we're talking about Copilot. And just like an AI pair programmer, it's gonna have certain strengths, gonna have certain weaknesses, and there are going to be specific workloads that it's going to be able to help out with, and that's exactly what we're going to see here.

That we're going to take a look at a couple of different modes with agent mode locally, with edit mode, with ask mode. We're also gonna take a look at what we announced at Build, our brand-new Copilot coding agent, which actually allows you to assign issues to Copilot.

And then we're also gonna spend an awful lot of time talking about context. Because as I mentioned, again, AI pair programmer, context is really key. It's key across many aspects of life, and it's certainly going to be key whenever we're working with any form of AI, and that does include GitHub Copilot.

So without any further delay, let's go ahead and get into it. Are you comfortable down there, John? Good for now. All right. Okay. [laughs]

Let's talk a little bit about context. And the way that I always like to introduce context is by, um, giving, uh, a little bit of, uh, of a quick story that, uh, my partner and I woke up the other day.

She looks at me and says, "Let's go get brunch." Fantastic. Who doesn't love brunch? And so I recommended a spot. And then she says, "But here's the thing, is we've been there an awful lot lately, and I'm kind of burnt out on it.

How about we go somewhere else?" Okay, fantastic. And so then I recommended a different spot. And then she thinks for a minute, and she says, "You know, I'm really kinda craving waffles."

Who doesn't love waffles? Fantastic. And so then I recommended another spot, and, and off we went. Now, that back and forth is, like, very normal to human conversation, that I was given a little bit of context, "Let's go to brunch," and then I gave, based on the context that I had, a perfectly valid answer.

And then a little bit more information was provided, and I gave another answer, and then eventually we found the solution that we were driving towards. And that's exactly how we're going to work with Copilot, is that we're going to give Copilot context.

We're gonna help point it in the right direction, and then we're going to work together to get to the solution that we are looking for. Now, whenever we're talking about context, there's oftentimes a lot of focus on the prompt.

Now, don't get me wrong, the prompt that we use for Copilot when we're using chat, when we're creating an issue, all of that is very, very important, but it really goes beyond just that prompt that we give to Copilot.

And I honestly find that a lot of times when people are first getting started with Copilot, that there's a little bit too much focus on that prompt itself.

Because what Copilot's gonna use for context is everything that it sees, and so that's going to include your code. So making sure that your code is readable is extremely important, that a lot...

uh, unlike a lot of other tools that you're gonna be using, where there'll be a script where it's gonna build your code or scan all of your code and look for different patterns and so forth, with Copilot, again, the AI pair programmer, it's gonna behave an awful lot like a pro- another programmer coming along and reading your

code. And if your code isn't readable, if you're using a lot of abbreviations, you're using, um, names that aren't clear, you're using single-letter variable names, which are the bane of my existence- [laughs]

... Copilot's not going to be able to easily understand that. On top of that, comments. Now,

I do have a little bit of a belief that code that's easy to read shouldn't need comments, that the code should describe well enough what it is that it's doing.

But we all know that that's not always the case. We all know that we fall short of that, and that a couple of lines of comments left behind is not only going to help you six months later when you go back to that code base and trying to figure out what it is that you were doing, but

it's going to help, again, that pair programmer and that AI pair programmer. So having in a few comments. And then last but not least is having a good project structure.

Allowing Copilot to be able to quickly find the different resources that it's going to need is also really important. So all of that plays into context, and that brings us into this spot right here of helping Copilot help you.

I sort of like to say, don't be passive-aggressive with Copilot, that don't throw something at Copilot and kinda, like, hope that it figures out what you really, really meant.

That if you know something or if you know that there's a particular piece of information that Copilot should be considering, tell Copilot that. And what you're gonna see is you've got a lot of great tools with which to do that.

So again, that context, all that background information, and we're gonna see a lot of different ways that we can do this, through, like, instruction files or, again, those comments, again, that good project structure.

The intent, be clear about what it is that you're trying to do and be clear about it, that clarity aspect. And when we're talking about clarity, for those of us that have maybe worked around with, like, old chatbots, and we got very used to just sending very terse commands because natural language processing back a few years ago

just was not really all that strong, so we were effectively using it like a command line interface.

We wanna be a bit more verbose, be a bit more flowery, make sure that we're easy to understand. And then last but not least, that specificity. If we want something done a particular way, let's be clear about it.

Let's get in and do it. So let's introduce real quickly here the different workloads that we have available to us. Now, the glowing one on the right is not necessarily to indicate that, hey, that is, um, uh, the best, but rather just simply that that's new and new things are shiny.

So over on the far left is code completion, and this is sort of the original version, if you will, of GitHub Copilot. That I'm typing away, I'm coding away, and then Copilot right in line is going to start making suggestions about what my next line, my next block, my next class, my next function is going to be.

And this is wonderful if you're in the zone, you know what you're doing, just type away, and Copilot can then help you write code.

And then we get into chat, and we get into edit mode. Now, chat originally just had ask, which is gonna be for single shot. "Explain this code to me.

I need you to create a file." Whereas with edits mode,

what that's gonna allow me to do is that's gonna allow me to edit multiple files in one shot. Because when we think about even the most basic of updates, say, like, I'm just updating a web page.

I'm gonna update an HTML file, a CSS file, and a JavaScript file.

There's very few, if any, code updates that are single file anymore. And so with edits, I can then guide Copilot through editing multiple files. And then we get into local agent mode, where now Copilot's gonna kind of lead the way, but what we're really gonna see with agent mode is that it's gonna behave an awful lot like

a developer, that it will be able to explore your project, it'll be able to find files, and it will be able to run external tasks. So it'll be able to build your code, it'll be able to run tests, and if it detects that anything has gone wrong, it'll actually be able to self-heal.

I'm gonna come back to questions in a little bit.

Last but not least is Copilot Coding Agent. And with Copilot Coding Agent, what I'm gonna be able to do is take an issue in my repository, assign that to Copilot,

and then I get to go on about doing something else.

So if I have, like, little tasks, little things that I just haven't been able to get to, I can go ahead and assign that issue, and then I can focus my attention on the bigger problems.

And so those are the different workloads that are available to us with Copilot. And so that is coding agent. We're gonna be able to give it a task, and then away we go from there.

So without any further delay, I'm going to actually, um, kinda leave that there, and let's go ahead and get started. So first thing, before you click on that URL, this is gonna be a real quick, um, um, test.

You know how you were probably in elementary school, and you got handed that, uh, sheet with, like, 40 steps on it? And step one was read all the instructions to the end,

and then step two was write your name, and then step 40 was just do steps one and two. How many people did all the steps?

Me.

Yeah. Yep, absolutely. Um, so in any event, um, this is gonna be one of those tests. So first thing is first, before you go there,

make sure that you have gone to your email that's associated with your GitHub account,

that you've accepted that invitation, and when you got asked, "Hey, do you want a Copilot license?" Say yes to that.

I have about 10 people who have not responded to the email. They can do this directly to go and accept since some of the emails aren't going through.

Okay. Um, give me one second here. Um... [laughs]

It's just the [REDACTED:url].

Okay.

And they should see a banner there if they haven't accepted their invitation.

Okay. Beautiful. Thank you. Well done, John. All right.

That's all. I just said well done. Thank you. Um, yeah. So if, um, you did not get your invite for whatever reason, you can actually just go directly to [REDACTED:url] and then accept your invite.

Now, I am gonna give you a minute to do that in the background, and then I'm gonna address the people that are hanging out in the, uh, in the back of the room here.

We are going to be doing the exact same lab at 3:30. So if you wanna do the lab, you wanna have a seat, you wanna be comfortable, you can come back at 3:30, you'll be able to do the exact same lab.

The 3:30 session is gonna be an exact repeat of everything that we are doing here.

Yeah.

All right. Now, if you do not have access yet to [REDACTED:username], then hang on. We'll be around to help troubleshoot all of that in a minute.

Assuming that you do have access, if you head on over to that URL right there,

what that will do is that will take you to... Boopity-boo. Um, let's...

Oops. Let me go to the right spot. There we go.

And there we go. And there we go. Okay. So that will take you to this little README file right here.

This is gonna give you an overview of the lab and everything that you're gonna be doing. You're gonna set up the environment. You're gonna assign some issues. You're gonna configure, interact with some external services, provide context to Copilot, complete a sitewide update, and then review Copilot's work.

And you'll notice all the way down at the very bottom, get started. We're gonna do this by getting everything, um, set up right here. We are gonna be using Codespaces, so you don't need any local installation.

You'll be doing everything via the cloud. So the first part is going to be setting all of that up. Follow the instructions that you see there. When it comes to this spot right here, and this is now where I'm gonna need everybody to pay attention to me.

So when you go in to create your lab,

where you're going to want to create it and how you're gonna want to create it, let me create a real quick new slide here. Boop-a-boo. Sound effects help. [keyboard clicking]

There we are. Typing skill is inversely proportional to the number of people watching. [laughs]

These better be passwords. [laughs]

Okay. So when you go to create your repo,

that's gonna be the owner that you're gonna want, will be [REDACTED:username]. It will need to be inside that organization, 'cause otherwise it's not going to work.

And then note the name. Just make that your GitHub handle. We'll kinda make it real nice and easy for everybody. So owner will be [REDACTED:username]. That's gonna be your name.

And again, if you did not see where to access the lab, that's where to access the lab. I'm gonna leave this slide up for a minute here.

That's where you're gonna access the lab from.

That's gonna be going away in five, four,

three, two, one. And then finally, that's where you can go ahead and create your repo.

Again, note the owner. You know what the name, and away you go from there. So I'm gonna let you start roaming through exercise zero. I'm gonna let you start roaming through exercise one.

If you have questions, that is exactly what John and I are here for. Now, please do keep one big thing in mind, which is the fact that there are roughly about 80 of you,

and there are two of us. We are doing our absolute best to run around as quickly as possible, but please be patient with us. Does everybody know what they should be doing right now?

Yes.

Okay. Last very important thing, I always assume that silence is a, "Hey, everything is fantastic." Neither John nor I are mind readers, so if something isn't going quite right, please, please, please say something.

Let us know. All right. Now I will let you go ahead and have at it.

All right, I'll be back in one second. [door closing]

Has anybody been able to assign an issue to Copilot?

Yes. I've assigned it.

Some have. Well, all right, let me do this again. Has anybody able to...

Has anybody been able to successfully have Copilot start work-

Yes

... on the issue? Couple of people. All right. How many people have?

Okay. Um, of those that just raised their hands, um, how many already had access to either Copilot Enterprise or Copilot Pro Plus?

Okay. That's... All right.

Not Pro Plus. That's allowed

Okay. Yeah. Okay. Yeah, we're trying to figure that out. Um, the org that we put everybody into is supposed to have that level of access. Um, apparently that doesn't seem to quite be the case.

So, um, in the meantime, um, here's what I'd like to go ahead and do, is kinda just start walking through the exercises here so that way you can at least see it.

The other thing that I do wanna highlight, and let me put this URL back up here. Um, now granted again, to assign issues to Copilot coding agent, um, you are gonna need Pro Plus, or you are gonna need, um, um, Enterprise.

So, like, that part of the lab you won't be able to do unless you have access to that. But if you have, um, um, even Copilot Free, um, you'll be able to, uh, perform the rest of the, uh, of the lab, and you can see that right there.

That repository is public, um, and you can go back and play with it all on, on, on your own, uh, later on, um, uh, later on there. All right, so let's do this.

Um, what I'm actually gonna do is there was a question here, I'm as- I'm assuming the question was about Copilot. The [REDACTED:gender] in red, the, um, the G-Shock watch.

Yes, sir.

Yeah, you had a question.

Oh, thank you. Um, I was curious, um, do you consider any of the modes vibe coding? Yes, vibe- [laughing]

So, um, I, uh, d- the, the question is, do I consider any of the modes vibe, uh, any of the modes vibe coding? And I would, um, say to a certain extent, basically anything that's going to be, um, agent-driven where, uh, you're going to have Copilot kind of, like, driving the operation rather than you driving the operation,

that would certainly fall under that category of, um, of, of vibe coding. Um, whether or not that's an approach that you wanna take of vibe coding all up, I will kind of leave that up to, up to you.

Everybody sort of has their, their own opinions on that. Um, and one thing that you will notice, um, about me is, um, I typically don't share a whole lot of, like, strong opinions, um, in situations like that.

So I don't necessarily have a strong opinion one way or another on that, but that kind of answers your, uh, answers your question. So yeah. Cool. Other questions about Copilot?

So I'm bringing this up in the background here.

Yeah, fire away.

How, how does it differentiate from Cascade and Windsurf?

So, uh, I'm gonna answer, um, Cascade, Cursor, Windsurf, and all of those questions all up, which is to say that, um, there's a limited number of hours in the day, and things move really, really fast.

I can keep up with what we're doing.

I can't keep up with what anybody else is doing. So, um,

I honestly am not familiar at all with any of the feature sets of any of the alternatives that, that are out there. Um, and honestly, like, going out, like, bashing competition and things like that is not necessarily my vibe.

Don't worry about it. Um, um, so what I would say is if you're going, "Hey, um, Windsurf does this. Can Copilot do it? Um, does Cursor do this?" Or, "Cursor does this.

Can Copilot do that?" I can answer those types of questions, but if you're, like, looking for, like, a feature comparison or things like that, I, I'm really not able to do that because, again, I just don't know those well enough.

There was a hand over here.

Um, as you're showing that Copilot can be more aware of the environment-

Yeah

... can it also be aware of live databases? Can it be connected to your SQL or some other data source so it has that context as well?

Yeah, so this is a fantastic question. So the question is, um, can Copilot be aware of, um, external, uh, data sources? Um, and the answer is not directly, but with a little thing called MCP or Model Context Protocol, it can.

So if you're not already familiar with, uh, Model Context Protocol, he says, bringing up the slide right here, um, the whole goal is to be able to expand, um, Copilot's capabilities.

So Copilot is built on top of an LLM, Large Language Model, um, and that LLM is always going to be static. Um, and so what MCP allows you to do is it allows you to give Copilot the ability to call out to external services.

And, um, the diagram looks a little bit like this. Um, I need everybody to memorize this. There's gonna be a quiz on this. In about 15 minutes. Um, and basically what you're gonna notice if you look at this is that your request is gonna go to Copilot, then it's gonna call out to the MCP server, which is

then able to access external resources. So one of the MCP servers that's available, for example, is GitHub. And so what I can actually do then with that MCP server is I can then go to Copilot and I can say, "Hey, create an issue on this."

So that way maybe I'm, I'm in the zone, I'm coding, coding, coding, and I realize, hey, there's something I wanna be able to look at later. Let me just go ahead and create a real quick issue on that, then I can do that right from, uh, from chat.

Or maybe I wanna go in and do a search. I can again do that right from chat. Or again, I've got databases and I wanna be able to, like, get that schema or I wanna be able to get that data from there, then I can do that with, uh, with my MCP server.

Now, a couple of real quick things on MCP servers. Number one is that there are a bunch of, um, first-party ones that are created. Um, like we have one, Azure has one, Playwright has one, um, and then there's a lot of community ones, uh, that are out there.

Now, here's the catch, is that MCP servers are not only able to access data on your behalf, but they're also able to perform tasks on your behalf.

So as a result, before you utilize a third-party MCP server, make sure it is something that you trust.

Or you can consider creating one on your own. I'm gonna admit I haven't yet created one on my own, but, um,

um, but, um, it is something that is, um, um... Sorry, I got

thrown. Um, oh, I haven't created one on my own, um, but I've seen a lot of people create them and it does seem to be something that's relatively straightforward, um, as far as setting it up that you can just capture the request, process it, and then send it off from there.

And then you basically just create a set of endpoints, um, for Copilot to, to figure out.

Okay. So then really quickly on that, if you have a backup of your database that's in like a .SQL file, can it consume that and use that as well?

Sure. Absolutely. Absolutely. Yeah. And in fact, you wouldn't even necessarily, like... If what you're looking for is to help Copilot write database queries really well, um, all that Copilot really needs at that point is your DDL, is your data definition language, and that's actually something that you can do, um,

internally inside of, um... Um, where do I wanna go?

I'm trying to remember this off the top of my head so I'm probably going to get the exact...

Oh, the Wi-Fi's gonna be wonderful here. Oh, come on.

Why? I am connected to the speaker Wi-Fi, yeah? Okay, that's supposed to be faster. [laughs]

There we go. Um... Nope, that's not it.

I think this is it. Um, yeah, it's something... There it is. Yeah. Um,

yeah, so what you could do, um, if all you have is just the DDL, is you could actually just include that with your instructions. Um, and then that way anytime that I talk to chat, then Copilot can go ahead and use that and be able to generate it that way and that's honestly simplest thing that works.

Okay.

So yeah. Okay. Um, yeah?

Um, just talking about like agents MD for, uh, Copilot instructions MD and scope of the-

Uh, a- absolutely. So let's talk a little bit... Let's actually do this. I'm going to, um...

Yeah. Yes?

I'm just not able to get Codespaces.

Yeah. Unfortunately, um, between Wi-Fi issues, access issues, and things like that, we're just not able to, to do that. So yeah. I'm turning this into sort of like live Q&A and live demos.

Trying to give everybody the best possible value that I can given the situation that we have. So yeah.

Let me do this. Make yourself comfortable, John.

Be, be, be. Whoosh, whoosh, whoosh. And then let me...

Let me do this. Okay. Um... [keyboard clicking]

Okay. So let's talk a little bit about, um, Copilot coding agent here. So what I've got here is I have, um, an issue that I've created- Uh, and this is just copy and paste retrieved from the lab, um, to have it create endpoints for creating and editing games.

And the first thing that I want you to notice about the issue here is, again, the context. The context is key here, that the whole goal of coding agent is to act asynchronously, that I assign an issue to it, and I just let it do its thing.

And off Copilot goes, and it does its thing, and then it will eventually come back to me. And that becomes really, really tricky because how do I then know whether or not Copilot has everything that it needs to be able to perform its work?

I don't know. And so that's the first big key. I always love the little eyes. That's the little indication that Copilot's now on the task. Kinda cute. Um,

so the first thing I wanna highlight is the issue. And you'll notice again I'm not being passive-aggressive with Copilot. And if I know what I want it to do, if I even know how I want it to approach the task, I'm gonna tell Copilot that, that the more that you leave for ambiguity's sake, the more that you

leave for the other party to figure out this is human or this is AI, the more chance that you're going to come back to something that you really didn't exactly want.

So if you want the wall painted a particular shade of red, then say that you want the wall painted a particular shade of red. And so that's exactly what I've done here.

But again, as I highlighted, it goes beyond just the prompt, and effectively that's what this is, is this is a prompt. And so Copilot supports some different instructions files.

Now, right now it does depend a little bit on where you are and what you're doing. But with chat and with coding agent, all of them support

copilot-instructions.md. So if you're using chat, and if you're using coding agent, this supports Copilot instructions- copilot-instructions.md. And if we take a look at this file, what I want you to note, it's just a markdown file, so nothing special, nothing fancy.

And what I've done inside of this file is I've given it high level overviews of what we're building, how we're building it, and my project structure. So you'll notice, for example, that I've got some guidelines right up top.

So this is a crowdfunding platform, uh, with a developer theme. The application uses yada, yada, yada. You'll also notice I've given it coding standards. This is what's required before each commit.

I've given it language guidance. And I've also told it how it is that I want my Python and Flask to be created, how I want my Svelte and Astro to be created, how I want my style, my, my actions.

I've given it information about the scripts that are available, and I've also documented my repository structure.

Chances are you already have this inside of your projects, or at least one would hope that you do.

And if you don't, here's a good opportunity to create it.

Hand that to Copilot. And so now anytime I make a chat request locally, or when coding agent does its thing, it's gonna be considering that.

Now, going one step further with coding agent, another big question becomes, okay, well, where's it gonna do its work? So as it turns out, coding agent behind the scenes is using GitHub Actions.

And you'll notice right here I've got a special action that's created that's called Copilot Setup Steps.

And so in here, I'm now having it install everything that I think it's going to need to do its work. So if there are any libraries, any frameworks, any services, anything like that that you need to have installed, any scripts that you need run, you can set that up right here.

So now Copilot is going to have this as its environment to get in and do its work, and it's also going to have this instructions file that we highlighted a minute ago to be able to act upon as well.

Now, on top of that, let me go over here to my pull requests, is I can see the pull request that Copilot made.

So just made this, you know. It was three minutes ago, so this is not a pre-baked cake. We're doing this live.

And if I open this up and I scroll on down, I can view the session here, and this will show me Copilot doing its thing behind the scenes. And eventually here, there we go, moving your mouse makes it go faster, what I can see is it's actually going out and it's exploring the project, and it's digging up

information on its own as well. So again, as we were talking, good code, clear code, good comments, good project structure, all of that helps your developers, and all of that is going to help Copilot out as well.

So I can give it information through the issue. I can give it information through my instructions. I give it information kind of implicitly through the project itself, and then I can also create that environment by setting up that Copilot steps.

There was a hand here first. Yeah.

Yeah. For, um, the custom instructions, are they available in, like, edit mode and agent mode and inline edits, or do you need to express by at workspace?

Yeah. So that's a great question. So... And I'm gonna answer the second part to that, uh, of that at workspace as well. So, um, when it comes to Copilot instructions, those are always going to be available.

Let me get rid of my red squigglies here. Um, those are always going to be available, um, inside of, uh, inside a chat here. So let's say I do this.

I'm gonna put this into, um, agent mode. Um, I'm gonna leave it as, uh, Claude three seven. And, uh, by the way, um, I do not have a stance on which model is better than any other model.

Um, you will notice, and you kinda picked this up in your lab as well, I, I was one of the, uh, the authors of the lab. Um, in the lab we always use Claude three five.

Uh, you'll notice any of my demos, I'm basically always using Claude. You can read whatever it is that you want from that, but I have no personal stance on which model is better than any other model There we go.

So, um, update the website to allow for filtering by, um, publisher and category. Add, uh, dropdown lists, and refresh the page when indexes, um, change.

Make sure the tests pass. Okay, so, um, go. So what I want you to notice, um, is... Oh, I put it into agent mode, so it's not gonna... I, I promise you it is gonna use the instructions.

It's just not gonna show it to me, unfortunately. Um, but on any of the modes in chat... Oh, well, there it is. I just needed to be patient. There's my Copilot instructions under my references.

So there it is. It's, it's using that, uh, that right there. Um, the other thing that I wanna highlight is, and this right now is particular to local chat, is I can even create, um, dot instructions files, and this is admittedly a little bit,

um... It's a little bit tricky to, I think, understand kinda the first time that you see it. Um, so kind of go with me on this one. So Copilot-instructions, universal.

Every single chat request, this is gonna go.

The dot instructions files, these become manual, so I can add these in manually to a task that I'm performing inside of chat. He says, "Delaying long enough for it to finally open."

Um, so what you're gonna notice, again, a markdown file, but this is now particular to a type of task. So this is for creating a Flask endpoint. And so you'll notice in here that I've given it en- uh, information about the endpoint.

I've given information about my, uh, my unit test. I've given it a couple of notes about the project, and I've even linked to files that it should use as a prototype, and these are actually just existing files.

So if I brought this in, now what it would do is it would follow all of those instructions there.

But let's say for example with, like, React components, just to use that as an example, um, that I wanna make sure that React components always follow the exact same patterns and practices.

So what I can do there is up at the very top, you'll notice the apply to, and then I can put in a path. So I could go asterisk, asterisk, whack, um, um, asterisk dot, uh, JSX or TSX if you're using TypeScript.

And now any time that you're working with a file that matches that pattern, it will then automatically apply that instructions file. So in this case here, it's gonna look inside of server tests, and any time that it finds a file that matches test underscore...

And you'll notice if I go into my, um, server [laughs]

tests, you'll notice test_games. That matches that pattern right there. So any time that I was working with a test file, that would then go ahead and, um, um, and match.

The last thing I wanna mention here is that all of this becomes part of your repository.

So is creating these files going to take a little while? Everybody go like this. Yeah. But this is very much like spending three hours to write a script for that task that constantly takes you a couple of minutes, that after a little while you're gonna get your money back on it, so to speak.

The exact same thing here. So the time that you spend here is going to help improve productivity and help ensure that your code generation is going to be the way that you want it to be.

Yeah.

I have a question. Um, for the workflow, does it have to literally name that code,

uh, for the Copilot stuff?

Yes, it does have to specific- Yeah, if you're, if you're using the workflow for setting up coding agent, it does have to have that name.

Okay.

And that is documented.

Cool. And for, like, the custom instruction commands, you can put whatever you want for, but it should be relevant to what, you know what I mean? Like, this is for Python.

Um, and, and sorry, one more question. [laughs] The last one is like, okay, this is all great, but our org has standards, so we want to put these at the org level.

You know, would it be propagated that way?

Yeah, so this is a fantastic question. So, um, so the question is, hey, about these standards, can we put these at, at an org level? And, um,

yes. So there's a few different ways now that you can approach that. Number one is there is an ability to set instructions at the org level, um, as well, so you could do it that way.

Um, you can also, again, stand up an MCP server in front of that and allow for searching that way. And then the last thing that I would mention, and we just recently, like literally yesterday, I think it was, um, announced this, is, um, Copilot spaces, um, where this is specifically on github.com, that what you can do is

basically point it at, at a repository, point that at specific files and say, "Hey, here's our knowledge bases. Here's how we want our code to be created. Here's all of our standards.

Here's good examples." And then that way when a developer comes along and they do searches on github.com, they'll be able to then, um, uh, raise the information from, uh, from there.

Okay. Thanks.

You're welcome. There was something over here. Yeah. I'm trying my best to be as fair as I can.

So from what I understand, um, the co- the agent is using the workflow to set up an environment.

Yep.

Um, and what if there's changes required to the environment? Is that up to the developer to add this, or can Copilot change the environment, change the workflow itself?

Oh, oh, okay. Yeah, so that's a, that's a fantastic question. So the question is, is, hey, about this, um, um, um, about this workflow file, um, is this able to, um, be like automatically created or edited by Copilot?

Um, and the, the short answer is no. Um, now I- if I was, like, working locally, like let's say I'm not overly familiar with Actions, which I'm not Um, then I could go in through Copilot manual, and I could say, "Hey, I need to create an environment that's gonna install this, this, this, and this," um, and let

Copilot generate this for me? Absolutely. But once I launch this into agent mode, um, agent mode is not gonna be going back in and editing that. Now, keep in mind, um, and I'm gonna kind of lead this right into, um, the next, um, kind of like logical question here.

Um, so keep in mind that agent mo- or, uh, coding agent, so when it's doing its thing in the background here, it does have an ability to like run scripts.

Um, so it can like run tests and things like that. And in fact, if I...

Where was I? Um, here and here, and

let me scroll on down to view session here.

I'm gonna zoom out, um, 'cause ironically I think it's gonna make it a little easier to read. Okay. Let me come down here. Um.

Hold on one second. Um, yeah, here we go.

Yeah, so, um... Yeah, and it looks like all the tests passed, although we're getting, um... Oh, that's cool. They pushed an update, um, to SQLAlchemy. I'll have to go back and now update the project.

Um, but in any event, um, the takeaway that I want you to get out of this is, um, the fact that this is running commands locally. Okay? And so that then kind of raises, um, a next big question, which I think is very directly related to, hey, could it go in and like modify that, um, that, that,

that initial setup workflow? Um, and there's this, it, it, it, it, it can't modify that, um, and it also is not able to access any external resources. So let me up-level this real quick.

Um, when it comes to coding agent, coding agent was very much built with security in mind. So the first big thing is it's built on top of GitHub Actions.

And if you're not already familiar with GitHub Actions, when you spin up a brand-new action to start running, it does so in an ephemeral space. So it creates the one space that it's gonna work in, does all of its work in there, and then once that's done, all of that's torn down.

So that's the only space in which it can work. Copilot only has read access to your repository, save for the branch that it's going to create, and it only has write access to that branch.

So in this case here, it's gonna be copilot-fix-two. Um, copilot-fix is what it's always gonna start with, dash and then the number of the issue that was, uh, assigned to.

I'm gonna... Yep. Um, so, um, uh, so in this case it was issue number two, so that's why it's copilot-fix-two. So that's the only thing that it's gonna have write access to.

On top of that, it does not have access to any external services unless you open up the firewall. So the firewall is going to be completely locked down. It is not able to call the outside world.

That includes, by the way, installing packages. So like let's say there was a library that needed to be installed, and it tries to install that, it's gonna fail on that unless I've specifically punched open a hole on that.

Now, the exception to that, the workflow that I create. That, that, uh, that, that initial setup workflow that we talked about? That workflow, 'cause now I can install those services.

So if there's anything that I know that it needs, then I can go ahead and do that, but otherwise it's not going to have access to any external resources.

So very much designed with that, uh, with that security in mind. So very long-winded answer, but there's everything you ever wanted to know. Yeah?

So with that in mind, you have both, uh, workflow run tests YAML that runs as GitHub Action on main to master or to main?

Yeah. So let's actually go kind of one, one step further with this. So, um, I am a, um, uh, I'm a good steward of my, um, um, of my repository.

And so when I create a PR into main, so I'm gonna use this one here, Dependabot wanting to, uh, to bump a version number, and we're gonna notice,

we're gonna notice... There we go. Um, that I have, um, uh, a workflow set up here to perform some testing. So it runs unit tests, and it runs some end-to-end tests.

So, um, that way somebody goes in, they created a, a pull request, and we're gonna confirm all of that. Uh, every organization should hopefully have some level of validation that PRs look good before they start merging them in, right?

Everybody go like this. Please, lie to me if you have to.

Yeah.

Fantastic. Now, um, here's the catch. Again, thinking with our, our security cap, um, I wanna make sure that, that any of that code is always gonna be something that, that, that I trust.

So hopefully anyway, I can trust all my developers, but when it comes to AI, I'm not entirely certain. So what we'll notice is that here's the PR that it finished, and you'll notice if I scroll on down here and I get to that section on workflows, that it has not run those tests, and it's only gonna run

those tests if I click that button right there.

And of course, before I do that, I should go in and review the code and everything else there. So yeah.

So question, they're, they're both referencing the same script?

Exactly, yeah. So, so the question is, is, um, so Copilot, when it did its work behind the scenes, and we saw this already, that it ran all of those unit tests locally, and then now we're gonna notice here that I'm gonna have it run those unit tests again.

I, I do the exact same thing with Copilot as I do with all of my other developers, which is that, that balance suspenders approach. So

I'm gonna up-level this again. Just because I introduce AI does not mean that any of the fundamentals of DevOps change. So let's think about how I wrote code before AI.

So some of it would be from my own knowledge, some of it would be grabbed from documentation, some of it would be copied and pasted from Stack Overflow and changing it and hoping and praying that it actually did what I wanted it to do, or maybe that's just me.

Um, and then eventually I'm gonna go ahead and I'm gonna run my test locally, hope that all of them work, and then I'm gonna create a PR.

Now, after we do that PR, now what are we gonna do? Well, we're gonna get another developer to come along and review the code. We're gonna run all of our actions, and we're gonna make sure that our tests pass, that our linters check out, that all of our security scans are run, that we're gonna do all of

those core fundamentals regardless of how my code is being generated, and that doesn't change when I'm using AI. So does AI run those tests locally? Absolutely. But am I still going to go in and double-check?

I absolutely am, so I'm gonna do that here as well.

So, um, can you get it to run- [coughs] ... all the tests when it's running locally, like give it more of a contextual base? [clears throat]

If I was, if I was doing dev work locally, I probably wouldn't run the full suite of... I wouldn't run a script that runs all the tests. I would probably run, like, a focused set and then-

Oh, I see what you're saying, yeah. So that, um, like, let's say I'm working on a larger project, and admittedly, this is a smaller project, so, like, when I run my, my unit tests or even my, even my end-to-end tests, you know, it's gonna take, like, 30, 40 seconds.

Um, but if you've got a larger project where now that's gonna be taking minutes, um, so in agent mode then I can go ahead and direct it. Like, "Hey, only run the tests on what you're working on until you get to the very end, and then go ahead and run everything."

So I could either just include that in the prompt. Again, don't be passive-aggressive with Copilot. If you want it to do something, tell it to do it. Um, that might also be something that I would consider including in the instructions file of like, "Hey, you know, make sure that you always do that."

Um, and then on top of that, one of the things that I've, I've noticed about, um, Claude 4 or Claude Sonnet 4, whatever the naming structure it is they're using, um, on that, is it tends to sort of, like, do that on its own, where it will go ahead and, like, run a smaller set of tests and

then, like, branch out and do the whole one. Um, which it, it's doing that on its own, but again, like, if you want it to do something specifically, always tell it.

Always tell it. All right. I'm gonna go over to this side real quick, and then I'll come back to the middle. Yeah.

So, um, does Copilot support streaming for the HTTP MCP servers, remote servers, yeah?

Does Copilot? Yes. Yeah. Copilot does support, uh, remote MCP servers. Um, if you're gonna be using that with coding agent, it will support that with coding agent as well, but I need to open up a hole in the firewall for it to be able to access that remote service.

Okay. And that's... Does that happen at a project level or-

Yes. Yeah, uh, that, uh, right here, if I go to

Settings, and I go to, um, Coding Agent,

there's my MCP. I can go ahead and set the, the, the list of my MCP servers there. And then on, um, Environment,

and then, um, Copilot. In here, there's, um, um, there's different, uh, variables that you could then go ahead and set to open up your firewall. All that's in, in the documentation, but that's where you would go to, to go ahead and do that.

You're welcome. Yeah.

So right now, the coding agents work with issues that are set within GitHub itself only?

Correct.

So if I do say Jira- [laughs] [laughs]

Yeah.

Um, would we have to kind of clone it? I don't know Jira

Yeah. So, so the question is, is, "Hey, we're using ADO, we're using Jira, we're using, you know, fill-in-the-blank for managing our issues. Um, how can I then use that to assign to Copilot?"

Unfortunately, um, as of right now, um, it's going to be GitHub-only. Um, I don't know whether or not it will stay GitHub-only or what a future plan might look like, um, but, uh, but yeah.

Now, one thing that you might wanna consider, um, is, um, if there is something in Jira that you want to assign to, to Copilot, you could create a relatively straightforward script to just, like, copy that issue over, um, and then go ahead and, and assign it to, uh, to Copilot from, uh, from there.

But right now, the issue does have to be inside of, uh, inside of GitHub.

I'm sure they'll have, um, development server and-

Oh, cool

... instance where you put Jira, so-

Nice

There you go. Yeah. Yeah.

How we can make the Copilot to use a [clears throat]

... different parts of our code libraries and they get different repos,

work on the current repo? So-

Cross-repo

... instead of creating things from scratch, it can use this

Yeah. So, um, this is a fantastic question, and I'm gonna, um, actually up-level this. So the question is, is, "Hey, we have, um, internal libraries- And those are created in different, uh, repos.

And we wanna make sure that Copilot's going to use those, um, uh, those external libraries when it goes in to, to do its code. So, um, first thing that you can do, um, is make sure that Copilot sees you doing it.

So Copilot is a great pattern matcher. And in order for Copilot to be able to use an external library or an external framework, it just needs to see how you're doing it.

Like, think about all the frameworks that you use on a day-to-day basis. Do you really know how they work behind the scenes? Like, I'm, I'm a Svelte developer. I have no idea how Svelte works behind the scenes, but I know how to use Svelte because I've read all the docs, and I've written all the code, and, and,

and I can get it to do everything that I want it to do. But I have no idea what it's doing behind the scenes. I wanna think of the exact same thing when it comes to Copilot.

Copilot doesn't need to see the source code. It just needs to see how you're using it, and then it can best understand then, in turn, how to, um, um, how to do that.

So, um, that's the first big thing is, like, show it examples of that. The next thing that you can then do is, again, take advantage of your instructions files.

So, um, what you can do is just list the API. So if I, um, if I'm using, um, a particular library, and I know that there's always, like, certain file types that are gonna be using that, then I could create that, that .instructions file, or I could list that inside my instructions file.

Or again, if it's a bigger set of libraries, put an MCP server in front of it, and then I can go ahead and allow it to, to search that way and be able to, to see it, um, to see it that way.

So kinda show it how it is that, um, uh, that, that, that, that you're using it. Um, [sighs]

and there was something else that I wanted to add there that will come to me, um, in a minute. [speaking faintly]

No. There's something else, and I just cannot remember what it is now, but yeah. So-

Enterprise... The big enterprise has

Yeah. You... Um, so this is a great question. So, um, uh, what about fine-tuning? And the short answer is right now, um, we, we don't, uh, support fine-tuning. Um, fine-tuning, as it turns out, is, is very tricky because one of the things that we've discovered in, like, working with customers and so forth is customers have codebases where

they're proud of a lot of it, and then they've got a lot of it that they're not necessarily proud of. And so training Copilot to understand, hey, this is the good stuff, this is the stuff you don't wanna look at, um, becomes a little tricky.

So this is, again, where standing, like, a, a up an MCP server really comes into play because now I can then better control, this is, uh, what I want you to be looking at, this is m- what I don't want you to be, uh, to be looking at.

So yeah.

How do I read them about the cost of assigning, uh, an issue to a Copilot?

Meaning, uh, my understanding is you... If you're on an enterprise plan, you get some amount of premium requests, and the Copilot agent is going to choose from some number of those, right?

But how do I think about that?

I, I am not a billing person. [laughs] I am going to... [laughs]

Uh, we've hit noon, so why don't we let most of them go?

Oh, I was looking at this clock right here. I thought I had six minutes. [speaking faintly] Oh, okay. All right. Thank you. I apologize for our network issues. Um, again, um, let me put the, um, uh, the one slide, um, back up.

There. Um, you can go ahead and check out the, uh, the lab from there.

Thank you.

Thank you.

Are there any GitHub stickers? [upbeat music]