Rubber Duck Thursdays

Hinzugefügt: 2026-05-31

[00:00:47][music] [music] [music] [music] [music] [music] >> Mhm.

[00:02:02]>> [music] [music] [music] [music] [music] [music] [music] [music] [music] >> Hello.

[00:05:25]Hello. [music] Hello. Hi, everyone.

[00:05:33]Okay.

[00:05:40]Right. Um Hi, everyone.

[00:05:44]Could someone kindly confirm if you can see my face on the screen.

[00:05:50]For some reason, I'm not able to see my video. [music] I'm not sure that's making it to the feed.

[00:05:58]Okay, there we go.

[00:06:02]Um I need [music] to use a different background.

[00:06:08]Um all right, there.

[00:06:11]Hi everyone.

[00:06:13]Good morning, good afternoon, good evening, depending on where you are joining in from. Welcome to today's Rubber Duck Thursday episode. So good to see you all on the chat. Um yeah, drop a quick hi. Let us know where you are tuning in from. I see a lot of folks streaming in from LinkedIn.

[00:06:35][music] So this is streaming This is live on LinkedIn, on YouTube, on Twitch.

[00:06:41]Hi Roy.

[00:06:43]Hi Dark. Hey Jay.

[00:06:46]Yeah, let us know how's everyone doing?

[00:06:50]What are you all working on? What's new?

[00:06:52]What's exciting this week?

[00:06:57]Hello.

[00:06:58]You're good. I'm also good. [music] Uh lovely weather here in Nairobi, Kenya. Um I saw the sun for about 2 minutes.

[00:07:07]And then I had to close my blinds [music] cuz the sun would just be um just directly on my face, but yeah, doing good. Doing good.

[00:07:18]All right. Um Roy, you're asking what are they going to talk about? I'm assuming they in this case is what we'll be covering on this live stream. Well, this can be anything, honestly. Uh so my routine is to for for us to go over the change log together. So the GitHub change log, just see what's new, what's exciting, what do you care about? So, we'll probably start the conversation from the change log and then that can evolve to be whatever you guys want it to be. So, if you want us to focus on a specific demo or specific feature, co-pilot features, then happy to to do that.

[00:08:00]But, for now I just open it up. If you have any questions, if you have um anything that you've been building you want to share with the community, this is [music] the right space to do that.

[00:08:11]So, if you have something really cool you've been working on, you can share with us and we'll celebrate [music] together.

[00:08:21]All right. [music] Um good.

[00:08:24]Thank you. Thank you, Abudu, for confirming. Yeah, I was having some bit of tech issues setting up the camera.

[00:08:32]It's a good Thursday. I agree. I'm glad it's good for you.

[00:08:37]Good evening. Joining in from Australia.

[00:08:40]Welcome to the show.

[00:08:44]Anthony, welcome from Kenya.

[00:08:47]Theval, welcome from India.

[00:08:51]Great. Great. Great. You have um Pina from Portugal. I hope I'm getting your name right.

[00:08:58]All right. So, let us know if you also have any questions. Um the purpose for this live stream is to just connect on a weekly basis and then just talk all things GitHub. So, if you have any questions, I'm happy to gear the conversation towards them. But, for now I'm going to pop my screen [music] on the I'm going to share my screen. So, just give me a moment here.

[00:09:24]And then we're going to start the change log.

[00:09:29]So, just pop in the screen too.

[00:09:37]>> [clears throat] >> All right.

[00:09:40]So, this is the change log. I'm going to put the link right here.

[00:09:47]So, just go over to github.blog.

[00:09:52]Um and you will be able to find the change log. So, this week, let's see what's new. This is week of 26th May.

[00:10:02]Uh today should be around 27th. So, we have a few announcements. We're just going to go over them, see what's new, what's exciting.

[00:10:11]I'm going to scroll all the way to [music] Right, May 26th. This should have been released um this week.

[00:10:21]So, first release here is our code coverage on pull requests is now in public preview.

[00:10:29]Um so, what this means is that you can now aggregate a percentage of your code that is covered directly in pull requests, giving reviewers a clear signal to help evaluate test completeness before merging.

[00:10:45]So, I think this is really useful for um open source maintainers. So, if you're getting uh um large amount of PRs, then we have this new improvement or new feature where you can see a percentage of the code that is being impacted by the proposed changes in a given PR. So, I think this is a really neat feature.

[00:11:10]>> [music] >> Um and any open source um maintainers on the live stream today, uh could definitely try it out. So, [music] it's code coverage. As you're reviewing your PR, then you do get this [music] nice um nice comment here with a percentage and overall percentage of the code that will be covered um that is being covered in that particular pull request. So, I think that's that's a pretty cool um and interesting feature. So, that's the first release that has been announced this week.

[00:11:43]Um what else do we have here?

[00:11:53]Um all right, this all look interesting.

[00:11:56]Oh, there's one here that I think has a really really big impact. So, for those who are in the education space, so perhaps you've been using GitHub Classroom, then this is a really important announcement that [music] GitHub Classroom um sign-ups are no longer available. So, the offering from GitHub is being retired. If [music] you're using GitHub Education, GitHub Classroom, then this is really something important to take note of.

[00:12:27]Let's read through it. So, starting today, [music] new sign-ups for GitHub Classrooms are no longer available as we transition to partner solutions.

[00:12:37]So, for those who have existing GitHub Classroom accounts, uh you will continue working business as usual, but this will go on up to [music] the 28th of August, which is when GitHub Classroom will fully transition to partner solutions.

[00:12:55]So, again, let's look at um what this means. Um so, after 28th of August, users won't be able to sign into managed to sign into managed classrooms, and the GitHub Classroom website will be decommissioned.

[00:13:13]So, there's a discussion here. Let me just open it in case you are interested.

[00:13:18]So, you you've been using um GitHub Classrooms for some time. There is a discussion here in case you have any follow-up questions, but you can join. Of course, they have more details what triggered the change.

[00:13:32]And um looks here that educators want um a lot of reliability when it comes to this platform, and GitHub is no longer able to support that. So, um we're going to be transitioning that to a partner solution. So, we have two partners, Codelio and um and in Classroom 50. So, we I believe that this particular discussion will have more and more details in in case you have any specific questions on what this means for you, what will be available after August of this year, etc. So, again, this is all accessible from the change log.

[00:14:12]I see a few comments on the chat, so let me try and catch up.

[00:14:17]Hello. Hi, welcome from Ethiopia.

[00:14:21]Good to see you all. Hi, Stefan from South Africa.

[00:14:25]Fantastic.

[00:14:28]Right.

[00:14:32]Okay, yeah. So, I see folks sharing their portfolios, what it is they do, so you can connect as well.

[00:14:41]Yeah, I agree that uh was a really cool um feature that just got released.

[00:14:48]Stefan says that that's an interesting feature. It should be built to pre-push hooks and fail if the percentage is below [music] the threshold.

[00:14:58]Hm. I do agree with that comment. That would be even more useful um if uh yeah, so I think that would be really really useful. So, automatically just run the just run the code, and if, as you've said, a particular threshold is not reached, then it just um basically either drops the PR or something like that. So, I think that's a really good um and and neat suggestion. Um not really sure where we can put that, but I'm sure that we have um communities where we can share that suggestion. I'm actually just going to note it because I think it would make the feature even more useful. What we have right now will at least give you a first glance. If you receive a new PR, you can just at first glance see the amount of code that [music] is being covered with that particular review, but I do believe that would be a very a very very useful [music] enhancement to the feature. So, that's that's really cool.

[00:15:57]All right. Um Okay, so that's the second thing that went live this week. So, again for GitHub education users, GitHub classrooms here will be retired in just >> [music] >> a few months. So, yeah.

[00:16:14]Um What else? What else?

[00:16:22]Uh >> [music] >> GitHub code quality repository enablement API. So, this looks like a new a new release. So, you can now programmatically enable and configure GitHub code quality on individual repositories using the new repository enablement API.

[00:16:41]All right. So, looks like now you can programmatically um use these two additional endpoints. So, one will allow you to either enable or disable code quality as the default setup for your repo. Pretty neat.

[00:16:55][music] And then you can also retrieve the current code quality configuration from your repo directly from your code.

[00:17:02]And these are the currently supported languages: C#, Go, Java, Kotlin, JavaScript, TypeScript, Python, and Ruby. So, that's I think another good feature for especially for um enterprise accounts.

[00:17:18]So, that's really something worth looking into.

[00:17:22]And then, right. So, this is another one that looks really interesting. So, it's an improvement as of this week.

[00:17:30]Targets Copilot models to organizations with model volts.

[00:17:36]Now, for enterprise owners, for business owners, I think this will really be interesting for you. So, now you have granular control over which Copilot models are available to each organization. So, within your enterprise, there's a screenshot here.

[00:17:54]So, within your enterprise, you can define which set of models are available for each of the GitHub organizations.

[00:18:02]So, you can see here with this new user interface, you can easily create a new access rule, >> [music] >> and then tie that to a GitHub organization, and then define the models that each of these organizations should access.

[00:18:18]>> [music] >> In this example here, we see that the B2B organization has access to >> [music] >> OpenAI models, while these other three organizations here have access to Anthropic models. So, this gives you more granular control in terms of model access across your GitHub organizations.

[00:18:38]So, that's really, really useful.

[00:18:41]>> [music] >> Um what has also been improved is that the default model availability experience has a refreshed interface.

[00:18:47][music] So, from one single page, you can choose which default Copilot models are available, and you can also set each model's availability to either enabled or optional. So, users within these individual organizations can either easily switch between the models that you make available to them, or you can just leave them as optional. So, I think that for enterprise users, that's something worth noting. You now have more granular control over who has access to which certain models. So, that's that's pretty cool.

[00:19:24]>> [snorts] >> And the last one is this very first one at the very top. Um Copilot memory has more controls for deletion, scope, and the Copilot CLI.

[00:19:38]So, I'm curious how many of us on the chat can let me know how many of us are actually actively using Copilot memory.

[00:19:45]>> [music] >> And if you're not familiar with the concept, also let me know. Happy to chat about it. It's fairly new.

[00:19:54]Um So, if you're not familiar with the concept of Copilot memory, I'm happy to just give a quick overview. But, we have a published improvement in that Copilot memory now includes improved memory deletion at a repository level of switch, [music] and brings further memory controls into the Copilot CLI.

[00:20:18]So, just to give an example that will help us understand what this means.

[00:20:23]Yeah, [music] and I see one of our GitHub YouTube viewers says that you're yet to be familiar with the concept of Copilot memory. So, just to give you an example, um here is our repo. So, this is an example of a repo here. If I go over to the settings tab, so we go over to the settings tab, I have my Copilot settings. I'll expand that.

[00:20:50]And then at the bottom here, you will see memory, and it's in preview.

[00:20:55]If I click on memory, this will show you Copilot memory, which is uh which is basically a functionality that allows Copilot to create a persistent memory store about your repository.

[00:21:14]So, as you're interacting with Copilot either on github.com from the CLI on VS Code, it stores facts about your repository. It could be instructions, your preferences. It stores them in what we're calling here Copilot memory, and then it makes this memory available across all the contributors of your repository. So, that means if in this case, if I'm working with an agent from the CLI, and then another agent, like the cloud agent for instance, can also refer to that persistent memory. The code review agent can also refer to that persistent memory. If I have that party agents accessing this repo, instead of starting from scratch, they can also make a quick reference to the Copilot memory.

[00:22:03]This also applies if because I have human contributors to this repo, and they're also using their own individual set of AI agents, we can have this shared memory that all these agents can make reference to. So, that is what um Copilot memory allows you to do.

[00:22:22]And what this announcement means is, as you can see here, right here from github.com on my repo, in the settings, I have the ability to now either delete or update the memory um the Copilot memory logs that I have. So, I can easily just delete them from here. And as you can see, the source for these memory logs is from the Copilot CLI.

[00:22:49]So, if I switch to Copilot CLI, so I'm just going to open this project but from my terminal.

[00:22:56]I'll open the terminal.

[00:22:58]Get into Key Mask.

[00:23:02]Hope this is visible enough for everyone.

[00:23:08]Yeah, so if I start for pilot, so I'm just going to type copilot on the terminal. This will launch the copilot CLI agent.

[00:23:17]And then I can now use the slash memory.

[00:23:20]I believe yeah, it's slash memory command. So we've now improved [music] these additional um commands that allow you to either turn memory on for your repository. You can easily switch it off or you can show.

[00:23:36]And this should um yeah, this should show the status of your copilot memory.

[00:23:41][music] And as you've seen from the repo side, you can now easily come in, delete, clear, etc. And again, to avoid having stale information, I believe this um this information gets dropped every should be about 28 or so days. I just so you're having fresh information about your repo available for agents to refer to.

[00:24:05]Okay, we have a question here. So does the memory get stored separately for cloud and for local? That's a good question. Now, if I go back to my repo here, so you see these four memories, and the source for these four memories is from GitHub CLI.

[00:24:25]So these memories were logged when I was working with copilot from my local session, my local CLI session, and they also reflect on the repository. So they're saved on a repo level. And what that means is since the cloud agent works in the cloud, it's not available locally, >> [music] >> it can also make reference to the same set of memories. So it's a singular it's a single persistent memory store [music] that is accessible both from your local agents as well as your cloud agents.

[00:24:57]So you can let me know if that answers your question, but as you see from this UI, these memories were stored from our GitHub CLI session.

[00:25:12]Okay.

[00:25:14]So, yeah. I believe that's a good that's a good improvement. So, this way you have more control. You can delete this memory locations. You can delete this memory stores. You can update them. You can switch them on or off for your repositories as you see fit.

[00:25:32]Okay. We have another question here.

[00:25:35]Does the Rubberduck agent have access to the Copilot memory also? Absolutely. A Rubberduck agent is a built-in agent that lives within the Copilot CLI. So, yes, it will have access to this Copilot memory.

[00:25:54]So, good question there. So, the idea is that all the agents that collaborate on your repository, since you can set this either on a user level or a repository level, that means all the agents that come together to work on that particular repo will definitely have access to this persistent memory. [music] So, this way you're not having to keep re-explaining what your project is, what your preferences are. All these can easily be captured in the memory, and if you kick off a new session, then the agent already has some idea of what it is you're working on.

[00:26:30]Okay.

[00:26:32]Um Uh Okay.

[00:26:39]>> [music] >> So, with that, I think I'm going to switch over that's the most recent announcement. Yeah, nothing else has come in. So, that's pretty exciting.

[00:26:49]So, what we can do is uh we had the GitHub Copilot Dev Days online version.

[00:26:56]How many of us were able to join in the live stream yesterday? It was close to 6 hours. Um we had a live event here on YouTube. So, just by a show of comments, so just let me know on the chat if you are able to [music] join the live stream yesterday because we had some really good conversations around Copilot in GitHub Copilot in VS Code as well as from the CLI. So, I'm happy to do a quick recap on that and just show a few demos. So, for those who are able to catch yesterday's event, that [music] was GitHub Copilot Dev Days. Uh let me know on the chat.

[00:27:35]If you're not able to, that's still fine. I'm happy to just do a quick recap of what it is that we covered.

[00:27:44]Hey Kajal, welcome to the stream. Good to have you.

[00:27:50]Okay. Um Cool. So, no more questions.

[00:27:56]Very insightful GitHub Copilot tips. Um I agree. We have quite a lot of new features being rolled out. So, this is a really good time to just spend some time and really thoroughly talk about what these features are and what it is you can do.

[00:28:12]So, since I'm not seeing anyone confirming that they were able to even to tune into yesterday's event, I'm going to just do a quick walk-through of the demo that I did around the Copilot CLI, which I think should get you started. If you've not used the CLI before, this can be helpful. If you've used it, I'll share some additional tips. So, you can just put your questions on the chat as we proceed. So, yesterday we had the GitHub Copilot Dev Days event. The recording is available on YouTube, so you can access it right here on YouTube on the GitHub account. You should be able to watch most of those sessions.

[00:28:50]But, what I focused on specifically was Copilot CLI. And the reason why we had this specific focus on the CLI was we we continue to see this uprising of CLI native agents.

[00:29:05]And the reason we see that is because developers do spend a considerable amount of time in your terminals.

[00:29:12]So, yes, you're you're writing your code on your files. Uh you know, you still do that majority of the day. But then, a lot of context is locked in the terminal. You are in the terminal either running your tests, you're in the terminal managing [music] Git, you're in the terminal um deploying your infrastructure, or looking at the logs after your build and your [music] tests fail. So, you do spend a good amount of your time on the terminal. And often, what happens is that either that context remains uncaptured or is just treated as secondary [music] context. So, to address that, we now have Copilot CLI. You've most likely interacted with it. It's an agent that lives within the terminal. It has so many built-in capabilities and so many features, >> [music] >> which we're going to spend some time talking about today.

[00:30:07]Now, in terms of getting started, you can easily get the Copilot either from the Microsoft Store if you're on Windows, or using the common um tools across different platforms.

[00:30:18]Now, what I want to focus more on is the three distinct modes in which you can use the CLI.

[00:30:27]Using it in its interactive mode is the most popular use case, right?

[00:30:32]>> [music] >> So, this way you have I'll switch back to my terminal.

[00:30:38]So, this way you have this um back-and-forth style of interaction with the agent. So, this is the most popular way of using the CLI, but it's not the only way to use it.

[00:30:49]So, one of the other interaction modes for the Copilot is using it in its headless state. So, this means that you can invoke the Copilot CLI agent as part of an automated workflow. So, in this case, you don't care about having back and forth conversations with the agent.

[00:31:08]You just want as part of your workflow to have a stage that sends a prompt to the agent, you receive an output, and then you take that output and inject it into the next stage of your pipeline.

[00:31:22]So, think of the many use cases you have around automation workflows, your CI/CD pipelines, and then you can now easily just have Copilot execute one or more of those stages.

[00:31:34]And to give you an example, >> [music] >> I'll switch back to my terminal.

[00:31:42]I'm going to exit, so I'll use {slash} exit.

[00:31:47]I'm going in to get into a different folder. It's called Rubber Duck Thursdays. This is the folder that I use to just prepare some demos that we can do [music] live with you on this live stream.

[00:31:58]And so, what I'll do is you'll see I have a script I have a script right here, RDT. So, I'm just going to run that script.

[00:32:07]And I will leave it running.

[00:32:09]In a different tab, let us let us inspect what we have in this file.

[00:32:16]Okay?

[00:32:17]So, our script file um is executing the script using bash. We're running it in in strict mode, and then I'm defining here that as output, I want a single file.

[00:32:30]Now, to give you some context is every single week we have this live stream.

[00:32:35]And before I show up on this live stream, I like to [music] just go through the change log and familiarize myself with what's new. So, I do this mostly every morning on Thursdays just to read through the change log, what's new, and then if I get some demo ideas that I we can come and do together, I also [music] do that. So, what I'm doing here is I'm trying to automate that process.

[00:32:56]So, that every single morning, this can easily be a notification that I get, >> [music] >> and as part of my morning setup, I just get a notification with the updates or what's new from the change log, what's new from the GitHub blog, and then that will give me some starters for the conversations that I have with you all on this live stream.

[00:33:18]So, that's the process that I want to automate a little bit. So, I have this script file and I'm telling it as output, I want [music] you to just give me a single file in the format of today's date hyphen RDT.md, and then I'm passing in a prompt to Copilot. So, here's the prompt.

[00:33:38]Right? So, here's the prompt. I'm using Copilot {dash} P, [music] or alternatively, you can use Copilot {dash} {dash} prompt, and then in double quotes, go in with your prompt. [music] Now, the first thing is if you're using Copilot in its headless state, in this case, we're using it as part of a script, you want to be very mindful and careful of how you use your quotes just to avoid any um shell misinterpretation of your special characters. So, in this case, I have my prompt inside double quotes, and I'm telling Copilot that you are preparing content for Rubber Duck Thursdays, a weekly um a weekly GitHub developer live stream. Today's date is this. Search and read content from the change log and the GitHub blog platform.

[00:34:25]And then once you do that, return a markdown document as structured as follows, and then I just give it the breakdown. I want a one paragraph summary of what's new this week.

[00:34:36]>> [music] >> I want a section for the change log. So, this should just summarize what's new in the change log for this week.

[00:34:43]I want to get just three updates. So, from the blogs, this should give me an idea of what's happening in the world of GitHub this week.

[00:34:50]>> [music] >> And then at the bottom here, I want Copilot to give me some demo ideas so that I no longer just have access to what's new, but I also have some demo ideas that we can come and try out together.

[00:35:04]So, I pass that as the prompt. [music] And then I I I pass in some additional parameters. So, I run this silently.

[00:35:13]This way I don't want Copilot to log all the session metadata. I just want it to [music] log the output.

[00:35:19]In the case where you're using it in this mode where you just have it as part of a workflow, you of course won't care so much about just the output. You don't care so much about >> [music] >> what happens behind the scenes. And then I'm passing in the dash dash no ask user. So, this way it will not attempt to ask clarifying questions to me.

[00:35:40]Again, because this will likely run in an environment where I'm not present.

[00:35:45]So, if it's part of an automated GitHub action, most likely it will get triggered when I'm not even close to my computer. So, it's just going to execute.

[00:35:53]And then the other recommended practice is if you're using any agents as part of any automation pipelines, you need to limit the [music] number of tools that it can it can access, as well as the number of allowed destinations, URL destinations. [music] So, this will just minimize um any undesired um out outcomes from your workflow. So, in this case I'm just strictly restricting it to the GitHub blog website. And then I'm writing that into our output file.

[00:36:26]So, I just executed this script and as output we should see a file with today's date.

[00:36:33]So, we are going to open that file.

[00:36:38]Today's date is 28th.

[00:36:41]So, we'll open that file and we'll see as part of that script uh we sent a prompt to Copilot CLI.

[00:36:48]>> [music] >> And then we did get back a paragraph.

[00:36:51]So, this is what happened this week from GitHub.

[00:36:55]And then we have the change log. And if you were there when we started this live stream, we actually went through some of these items in depth. [music] So, you get a quick summary of what is new from the change log and I have a link that I can just click and verify.

[00:37:12]And then I get this one-sentence description of what's new. So, I can use this just to prepare for this particular live stream.

[00:37:21]So, you can see it has surfaced some of [music] the new the new announcements that we just talked about from the change log.

[00:37:30]And then [music] Yeah, and then at the bottom here we have a section for the updates. So, these are the new blogs that have the recent blogs that have been published on the said website. So, that's good.

[00:37:42]And then the last thing is I expect for it to give me some demo ideas. So, I can show up on this live stream with something at the back of my mind that we can do together. So, this is one of those modes that you can interact with the CLI.

[00:37:57]>> [music] >> It's not interactive, it's not back and forth, but you can already see the potential for me to stick this in a GitHub action and then every single morning I get I get like a a a message probably on Slack or on Teams and then just have that as part of my morning setup routine. So, you can already think of the many use cases and the many um projects that you can automate and then just have CLI part of that workflow.

[00:38:27]Okay, so we have a comment here from Muhammad. Says, "The [music] Copilot is not pretty good as a code agent. It doesn't understand anything and algorithms in multiple languages unified together [music] ecosystem."

[00:38:43]All right, so looks like you're having a frustrating, um, experience there with Copilot. So, do you mind sharing a little bit more about your setup? All right? Like, how have you set up your environment to use Copilot? Are you using any custom instructions? Are you using any customizations to get more out of Copilot?

[00:39:05]Um, so I think I would be curious just to hear more about that. If there's anyone else who has either a similar experience working with Copilot as a code agent, or a different experience, you can also let us know. But, my own personal experience is that out of the box, you actually um, if you're able to figure out how to pair the right model for the right job, and what I mean by that is, and we can give you a very practical example, is if I am going straight to a coding task, so I know the exact code that needs to be written, I like my go-to model would be GPT-3.5.

[00:39:44]It's It's a very powerful model when it comes to writing code.

[00:39:48]But, if I have a task that involves designing any form of UI, [music] I do not use GPT-3.5 because I don't get very good results.

[00:39:58]But, I just use, say, um, a Sonnet model. Sonnet 4.6, for example, does a fantastic job at simple UI design. So, if you crack that, just mapping the right task to the right model, the beauty with the Copilot CLI, and of course with GitHub Copilot, is that you get access to different models from different families, cloud models, um GPT models. So, you're able to have all these models working together and you can leverage their different strengths [music] and substitute their different weaknesses. So, I believe Muhammad Muhammad I would come back to how have you set up your workflow to work with co-pilot. So, out of the box you will get fairly good results. That has been my experience so far. But, you can still take it a notch higher.

[00:40:48]I'm going to switch to my terminal.

[00:40:54]I'm switching to my terminal and I'll go to the awesome co-pilot website.

[00:41:01]Um Muhammad, just let me know if you are familiar with this site, >> [music] >> but this website basically contains um some community contributed customizations and personalizations that you can use with GitHub co-pilot. So, I see you follow up your comment with um hallucination results. So, probably these are some of the These are some of the frustrating experiences you're having with co-pilot so far. So, what I would recommend and I'll drop this on the chat for you is before you even start using co-pilot, just go through this site and see if you can pull in some customizations before you engage your different agents. So, what I mean by that is let's say for instance you have your own specific set of coding standards that you want the agent to appear to out of the box. Then, by default it will just try and do the best it can from its training data, but then you can come in and add your custom instructions. So, if you scroll through this page, you'll see that we have so many instruction files. You don't have to write this from scratch.

[00:42:16]>> [music] >> And an example that I can give you is let's look for security.

[00:42:23]I believe we should have some instructions on security. Let's open that file.

[00:42:28]So in addition to just using Copilot as you get it out of the box, you can choose to >> [music] >> always use this security and OWASP um custom instruction.

[00:42:39]>> [music] >> So what this means is as your agent is working, it will always refer to the instructions that are in this markdown file.

[00:42:47]So you can see that in this case it's providing a comprehensive secure coding standards based on the OWASP top 10 2025. This needs to be updated.

[00:42:56]>> [music] >> With um with over 55 anti-patterns detection rejects, >> [music] >> framework specific fixes, etc. So what you do is from this particular website, you just come in. If you're doing a very specific task, find an instruction or find a custom agent or find a skill or find some hooks or some plugins that will simply just improve the outcome from these agents.

[00:43:24]So that's something that I'll share with you. Probably just give it a try. Um it's a really, really useful um >> [music] >> site where you can just come in here. If you want Copilot to do one specific task and do it very well, you can define custom agent. So instead of just using the general purpose Copilot agent that you get out of the box, you can come in here, pick a custom agent, give it the specific task. So if you're building your own system, you can have this accessibility expert implement or enforce accessibility policies on your particular application. So you're not restricted to just using Copilot as it comes out of the box. You have [music] a very broad spectrum of customizations that you can bring [music] in and then just configure a workflow that reflect how you love to code.

[00:44:18]So, I hope that answers your question.

[00:44:20]Please do give it a try and uh let us know if you get any luck uh or improve the outcomes that you're getting from Copilot.

[00:44:30]Yes, I see your comment here that you've used it uh in your VS Code environment and ruin all code structure. I think this is this is more of a setup of a setup challenge, not necessarily from Copilot because remember these are still language models. They will follow instructions. If you add Copilot into a code base that does not enforce uh you know, the recommended practices, it's going to pick up on those on those practices. So, if you've not properly um you're not using meaningful names for your functions, for your variables, such minor things, >> [music] >> it's going to just learn from your code.

[00:45:10]So, inasmuch as you're having these agents do most of the implementation from you, >> [music] >> the learning is two-way. So, it also tries as much as possible to learn from your from your existing practices. So, I think this comes down to how you set up your environment with the agents. Ensure you have the right guardrails and instructions in place. Restrict [music] the amount of permissions that you give to these agents. So, it shouldn't just be able to delete files, move files any howly. Just take some time and then structure a framework that you want all these agents to adhere to. So, I'll just again refer you to the awesome Copilot website. This is your one-stop shop for all the customizations that you can bring in to use these agents.

[00:46:01]All right, Philip, I see you have a question here. How does GitHub justify fees as legitimate?

[00:46:09]Um do you mind clarifying what that fees [music] is in your statement? What exactly are you asking about? Um what are you referring to as as um as part of your question? Just clarify that for me.

[00:46:32]All right, so there's a question here.

[00:46:35]In GitHub Copilot for VS Code, is there a way to configure auto mode so that it always selects GPT Mini instead of defaulting to Codex models in order to consistently use the lowest cost models?

[00:46:52]Um good question.

[00:46:55]And my answer to that will probably not what you're expecting because if you just think about how auto mode works, and probably I can pull in the documentation here.

[00:47:07]GitHub Copilot CLI auto mode.

[00:47:13]Okay, so I think it's this first result.

[00:47:17]Yeah, so if you think about how auto mode works, it's backed by two systems right here. So auto mode works um to intelligently choose the best model for you.

[00:47:28]>> [music] >> And behind the scenes, it's using two systems. So one system will go and look at the models that you have access to.

[00:47:36]So the models that you can use. And then it's going to look at the model health and the model availability. So it's going to eliminate any models that probably are not accessible. They're they have some bit of issues. It's just going to surface uh out of this list, it's going to um narrow down to the healthy models, models that are currently available. And then system number two is now going to focus on your task. So it's going to analyze the complexity of your prompt, of the task that you're giving it. And then it's going to combine the two to make a model selection for you.

[00:48:12]So I believe that by virtue of just how auto mode works, it would be difficult to >> [music] >> to have like a default landing for auto mode because as you see these >> [music] >> factors will always vary. You will you have zero control over model availability, over the model health.

[00:48:32]Again, this depends on the task that you give it.

[00:48:34]>> [music] >> So it's a bit non-deterministic, but if I think more about your question, if you do want to always default to GPT mini, I believe that's a separate setting that you can use. So I wouldn't recommend you go with auto mode if you've already identified that you want to use GPT mini for your use case, you can just directly go on and select that as the default model.

[00:48:59]>> [music] >> I do believe that in VS Code Let me open VS Code here.

[00:49:07]I do think that that's an that's a setting that you can use.

[00:49:12]So let me open up settings.

[00:49:16]Um let's look for default model.

[00:49:24]So right here under chat So for your agents, you can select a default language model to use. This is for the X plus up agent.

[00:49:36]I don't know if we have one for the general purpose agent.

[00:49:46]Yeah, but you can see they you have like different options for you to set like default models you want to work with.

[00:49:53]This can be for the different sub agents. So, build you have very many agents already built in before you even bring in your custom agents. There's uh there's an implement agent, there's an explore agent, and so you can define the default models for each of these agents.

[00:50:08]So, I I would recommend just looking through [music] um yeah, so looking through your settings and then just because you've already identified that you want to use GPT uh GPT Mini as as your default model, then you can just easily set that in the settings.

[00:50:28]Hope that's clear. [music] All right.

[00:50:37]Um Okay, uh Philip, I'm just trying to follow up on your question.

[00:50:52]Um Okay.

[00:51:05]Yeah, so I hope I hope that gives some some bit of clarity uh behind like how auto mode works and how you can just play around with the settings on VS Code for you to define the models that you want to run by default.

[00:51:20]So, yeah, uh back to my slides. Again, keep the questions coming. So, back to my slides, we've looked at using or running Copilot CLI in its headless mode.

[00:51:31]Uh you've seen how you can use it in its interactive mode. This is like the most popular way of working with Copilot um in the agent, and you can interact with the agent and the different features through the slash uh through the slash commands.

[00:51:49]Um so, Philip, I'm not ignoring your questions. I'm just having a hard time understanding what the question is.

[00:51:57]Um Yeah, so you have your you have your questions like as different comments coming in and I'm getting in comments from YouTube, from LinkedIn. So, maybe just try and have a single comment with the full question. So, this way I won't have to struggle reading through all the comments just to piece [music] everything together. So, Philip, if you could do that, that would really be helpful. And if I haven't answered your question, I will definitely give it to you.

[00:52:30]Yeah, so as you have several comments, just try and consolidate that for me because I'm trying to manage comments from a variety of sources.

[00:52:38]And yeah, so apologies if that's getting lost in the comments.

[00:52:45]Okay.

[00:52:46]Um So, what I'll do here is I'm going to show you some additional built-in agents again that you can use directly from the terminal.

[00:52:56]Now, I'll play Let me just re- [music] play this because it's pre-recorded just to save us some bit of time.

[00:53:04]Um so, I'm in a project here. So, I'm just going to get into a new project.

[00:53:08]I'm going to launch the Copilot CLI agent.

[00:53:13]Um so, the first thing is you confirm here I'll confirm here that I don't have any custom agents that I have >> [music] >> added. So, you can see I don't have any custom agents. So, I'm going to use the built-in agents that you get out of the box with Copilot CLI.

[00:53:29]So, the first agent that we'll look at is the code review agent. So, this is a built-in agent available in the CLI. It comes out of the box. Where before you push your changes on GitHub, you can run {slash} review, and this will use a dedicated agent that just do does a thorough code review of your local changes, useful before you even push your changes on GitHub.

[00:53:56]I see there's a new feature. It's currently in experimental [music] mode, where you can use a security review agent just to focus on the security vulnerabilities aspect of your changes. But for now, we'll just use {slash} review, and this will invoke the code review agent. Now, this is separate from the general CLI agent, and you'll see that it's using the So, it's it's now using a code review agent. It's reading through my local changes. It's reading through my files. It will attempt to build and compile the application, and then shortly we should see a summary of the code review findings. So, this is a built-in coding a built-in custom agent that just allows you before you even push your code just to have a surface level It's like just have an extra pair of eyes looking through your code to surface some obvious bugs, some obvious vulnerabilities, some approaches that you can substitute just to improve the quality >> [music] >> of your code.

[00:54:59]So, you can see it categorizes them as medium or high or low, which is which is pretty neat. Now, at this point, I can choose to either tell the agent to directly address all these issues, or I can have the agent log them as GitHub issues and and then walk through them one after the other.

[00:55:18]Or other option, which is what I'm going to do, is I can ask for a second opinion. So, I can ask for a second opinion [music] using yet another built-in custom agent, which is the rubber duck agent. We had a question earlier about the rubber duck agent. If you don't know about it, then [music] this will probably be helpful.

[00:55:40]So, after the code review agent has finished the review, it has surfaced these issues. I'm going to directly invoke the Rubberduck Agent using {slash} rubberduck.

[00:55:55]So, I'm going to invoke it using {slash} rubberduck.

[00:55:58]And I'm going to provide I'm going to provide a prompt here. So, this will allow me to get an independent critique of what we've done so far. So, I'll ask the Rubberduck Agent to review the findings above, to compare with my code base, and then surface any gaps.

[00:56:16]And what you'll realize here is that my general agent is running using an Anthropic model. This is running using Sonnet 4.6.

[00:56:25]And so, as soon as I go in with my prompt, um the general model acknowledges that this is a This is a request for the Rubberduck Agent. So, it gathers the context from my workspace, and then it will send that to the Rubberduck Agent. So, this is an independent agent [music] that lives in the CLI.

[00:56:45]And so, what you'll see is that shortly the Rubberduck Agent will pick up the task, and you'll realize that this agent is using GPT 5.4.

[00:56:54]So, what is happening behind the scenes is that Rubberduck is designed in a way that it enforces cross-model family validation.

[00:57:03]So, that means if my general model is an Anthropic model, so I'm working with Sonnet 4.6, then the Rubberduck Agent will come from a different model family, so the OpenAI model family, hence why it's running GPT 5.4.

[00:57:19]So, we know that these different model families have their own set of strengths and weaknesses. So, with a Rubberduck Agent, >> [music] >> you basically get the best of both worlds. So, if anything was missed in that initial review for by by using the Sonnet model, then GPT-5.4 is most likely going to pick up on it.

[00:57:42]And the team behind this feature actually published findings that if you use your general agent plus a rubber duck agent, >> [music] >> then you get a performance level that is close to Opus level.

[00:57:56]And we know that the problem with Opus is how expensive the Opus models are.

[00:58:02]So, what this means is you can use a fairly affordable model, Sonnet GPT-5.5, pair that with a rubber duck agent, and that will give you a performance level close to what you would get with Opus.

[00:58:16]So, you're getting something close to what you would get with Opus, but at the cost of more affordable model. So, that's the whole design pattern behind the rubber duck agent. So, if you run your main like if you run the main agent using a GPT model, then the rubber duck agent is going to spin up using a cloud model, and vice versa. So, that's an interesting concept. I challenge everyone to just try it out, see if you note any improvement in the outputs and the outcomes that you get from the agent.

[00:58:56]Okay, um All right, so Philip, now I see your question.

[00:59:02]Uh let me just put it on the screen. So, on GitHub, repos are posed as MIT license and educational. They get flagged as malicious by most security platforms. I'm unable to post more.

[00:59:17]I can send [music] in a single Hmm.

[00:59:25]Yeah, um Just so they get flagged as malicious by most security platforms.

[00:59:33]So, I'm I'm not sure. I'm just let me know if this um answers part of your question because I think the last part of it cut off. But, whenever you're using Copilot, there is an explicit setting that you can configure. And what this Actually, let me just show you right here.

[00:59:56]So, there's I don't know if you've heard of the um block suggestions matching [music] public code um setting. So, let me see if I'm going to find it here.

[01:00:11]Actually, the Copilot settings.

[01:00:19]Um Do do do do do do do do do do do do do do do do do do do do do do do do do do do do do do do do do do do do do do do do do do do do do do do do do do do do do do do do do do do do do [music] do do do So, suggestions matching public code.

[01:00:34]So, if you have this allowed, what this means is as Copilot is generating your code for you, so it's generating code to eventually um review to you as the user, before it shows you this code, if you have this setting enabled, it's going to look at the generated code and just look um [music] and just compare it against the full index of its training data set.

[01:00:59]And if it finds code that matches what it has generated, then it won't show you that code.

[01:01:06]Right? So, if you have it enabled, then out of the box, Copilot, just before showing you the final code snippet that it generates, it's going to look at it, compare it [music] with a full index of code that was used to train that model.

[01:01:21]and if it finds an exact um code block block of code, then it's simply not going to show you that particular piece of code. If you do not have this enabled, it's going to show you the code, but it's going to link you to where that particular code or to where it has seen similar code, and it's also going to give you information about the associated license. And so, with all that information, you can now make an informed decision of what to do with the suggested [music] code. So, the two options here is you can enable this option.

[01:01:58]What will happen is before Copilot shows you the final code that it has generated, it's going to look at the look at it against the full index. If it finds similar code, it won't show you.

[01:02:10]Or if you have it switched off, it will show you the code, but it will be transparent and let you know that, "Hey, this is where I found some code that matches what I have generated." It will give you a link for you to go and look at the code yourself, and it will also give you information about the associated license. And with that, you can make an informed decision on what you want to do, how you want to proceed with a particular code.

[01:02:35]So, that was the case last time I picked that up was in the VS on VS code. I don't really know how that looks like from the CLI, but yes, we do have that specific setting that you have to either enable or disable for your particular Copilot usage. So, that should address part of your question around licensing, right? Then, yeah, um I this piece this part I don't really quite understand. They get flagged as malicious [clears throat] by most security platforms. So, that's not really really clear for me. In case someone on the chat has a better understanding of that question. Um happy to happy to have your help in the discussion.

[01:03:23]>> [clears throat] >> Okay.

[01:03:30]All right. Uh but I think what I just shared is a general comment here and this is not specific to GitHub Copilot is that at the end of the day, these are powerful models which can be used for fairly anything. Yes, we'll advocate [clears throat] for people to use these AI coding agents or any AI agents for that matter, um use them for good.

[01:03:52]But again, in the wrong hands, then we do have and we've heard of cases where people exploit systems because they have access to very powerful models. So, at the end of the day, it really is within the control of the user. So, how you choose to implement and use these coding agents to some extent might not be within the control of the provider, but the providers, of course, do have the responsibility to have built-in guardrails where it becomes extremely difficult to be a bad actor using these models. So, again, I will just reiterate on that fact. Yes, we'll advocate for responsible use of AI, but unfortunately, that will not always be the case. So, you have to also use it very carefully, exercise a lot of caution. If you're pulling in um customizations, uh let's say you're pulling in custom agents that people are using out there, you do want to take an extra step to validate what it is [music] that you are getting from these models.

[01:04:55]Okay.

[01:04:56]Um so, I see we're out of time, but I have just one more demo to show.

[01:05:03]Uh so, you've seen how you can use the two built-in agents, that is the code review agent, to review your local changes before you push your code. And then to the rubber duck agent to enforce that cross model family critical validation.

[01:05:20]>> [music] >> And then lastly here is we all know that the relationship between developers and agents continues to evolve.

[01:05:30]Yeah? So that relationship continues to evolve. It's no longer a one-to-one, so it's not just one single developer working with one agent. [music] We do have multi-agency workflows or systems where you have an agent working with sub agents. And out of the box without [music] any additional customizations, Copilot CLI supports a hierarchical framework where you can have one main agent >> [music] >> dispatch or distribute tasks to other sub agents, manage them, and then just consolidate their output.

[01:06:05]And so for that, the last part of this demo is using the {slash} fleet command, right? So I'm going to switch back to GPT 5.5.

[01:06:16]I'll stick to the default reasoning effort, that's medium, and the default context window.

[01:06:22]So what you'll see here is I'm going to use the {slash} fleet command, right? And then I'll go in with the prompt. We now have the identified issues from the code review. Address all the issues in this code and show you have one list to track everything as it's as they are fixed.

[01:06:40]>> [music] >> And then test this project. It's an extension. It's a visual extension. So test the project before you exit the loop. And so what fleet does is that my main agent here, GPT 5.5, is going to analyze my prompt. It's going to break it down into individual [music] items.

[01:06:56]It's going to identify which can run in parallel if you have some form of dependencies.

[01:07:02]And then it's going to dispatch three different sub agents, each with their own focus areas. So, we have the three sub agents running here, and they can use {slash} tasks to closely monitor just manage the different sub agents and see them as they work.

[01:07:20]So, what happens behind the scenes here and what makes this a really powerful built-in feature for Copilot CLI >> [music] >> is that these sub agents run their own individual context windows.

[01:07:34]So, the back and forth the loop that these three individual sub agents are running >> [music] >> do not count into the main context window, but rather they are their own separate context windows, and then this main agent, the orchestrator agent, is just going to validate the output from the different models.

[01:07:53]>> [music] >> And you're seeing here we are seeing you're getting a prompt to store this as a memory point. So, if you were here at the beginning of the live stream, we talked about Copilot memory. So, this is how it looks like. This is you being asked by the agent, "Hey, I've learned something new about your project. Do you want me to store [music] it in the Copilot memory?" And then this way that Copilot memory will be accessible across all the agents that interact with this repository.

[01:08:21]So, now you can see here the main agent is monitoring what these different sub agents are doing. It's tracking the completion of the tasks. It's going to validate um the output. It's going to run the tests, and eventually it's going to give me a consolidated report of everything that was completed and achieved by the three different agents running in parallel.

[01:08:45]So, this is useful because you don't want to block your main context window.

[01:08:50]Remember, um the more your context window is filled up, the lower the quality of the output. So, what happens here is with these distinct sub agents, each running their own context windows, then that means that my main agent's context window remains to be clean, and it's only getting this output and factoring in output from the individual subagents.

[01:09:14]So, yeah, so with that um I hope that this demo was useful. Just again, sharing some bit of best practices, how you can use the CLI even more, how you can uh have like different agents collaborating with each other, how you can leverage different built-in custom agents, use the rubber duck agent to improve your performance, use the code review agent to just do a quick um a quick review of your code before you push it. [music] And yeah, so let's see if there's one more thing we can look at before we exit.

[01:09:56]Yeah, so this this last mode um this last mode is is really interesting, but I believe we do not have enough time for it. So, what I'll do is I'm just going to quickly talk about running Copilot CLI in server mode. Right?

[01:10:13][music] And so, if you run Copilot CLI in server mode, it exposes a JSON RPC port, which your client applications can now um connect to, and have Copilot CLI as a core AI backend for your systems.

[01:10:30]And to put this into perspective, if you've not tried out the GitHub Copilot SDK, I believe this should be your um your your homework, if if you will, your homework for today's session. Just go out and try on and try out the GitHub Copilot SDK, [music] because this shifts the conversation. It's now not you building with AI.

[01:10:54]Now you're using Copilot CLI power AI functionalities for your applications.

[01:11:01]Now, I have another project here that I will briefly demonstrate the concept of running and using Copilot CLI in server mode.

[01:11:11]This here is StudySync. [music] It's a little solution that I use to manage my school work. So, you can add in your different courses. You can add in your different notes, lecture notes, additional reading material. And then I recently added this AI chat feature.

[01:11:28]Basic concept [music] to chat on top of your lecture notes. So, for students, this can be useful to just >> [music] >> um ask the agent, "Hey, where exactly did we talk about this concept? Which lecture was that?" Yeah, the other stuff. So, it's just basic chat over document functionality.

[01:11:45]But, the back end behind this system is not Foundry, is not LangChain, is is basically Copilot CLI. And I'm using the SDK behind the scenes to connect to a local instance of Copilot CLI, which is what I'm using as the back end for my AI features. So, if I switch back to the terminal here and launch Copilot CLI, and then I will use {slash} resume to see the sessions, the local sessions I have with this agent. You'll see that this last conversation that I've just had on my application was actually logged as a CLI session. And you'll see the exact prompt that I sent. You'll see the custom tools that the CLI agent used. And you'll see basically the whole conversation that I had with this agent via my client application.

[01:12:38]So, this is the third and interesting way of using Copilot CLI. So, you can build your own POCs. If you're putting together a prototype for your organization for AI solutions, before you even go off to think and explore agent hosting platforms. If you already have access to GitHub Copilot, you [music] can leverage CLI the CLI and just have it as a back-end for your AI [music and clears throat] features. It's really easy to get started. We have proper documentation on the Copilot SDK.

[01:13:13]It's [music] available across um a variety of of languages. So, this is definitely something that you can try out yourself today. [music] So, if you're yet to try it out, let me just grab the link for y'all.

[01:13:29]That is GitHub Copilot SDK.

[01:13:34]Should have [music] the repository here.

[01:13:40]I'm going to put it on the chat.

[01:13:44]And this will basically allow you to programmatically connect [music] your applications to use the CLI as the back-end for your AI features. So, definitely give it a try. Let us know um let us know how the experience is. We have these available SDKs and we do have some additional ones that are supported or maintained by the community. So, things like C++ we do have such variations, but they are entirely supported and maintained by the community.

[01:14:17]Okay. Um see any last questions?

[01:14:22]Next week is Build, by the way. So, looking forward to an amazing time next week.

[01:14:27]Uh for those who will be there in person, enjoy Build. Most of us will be joining online. So, I know we have so many interesting sessions. And just before we wrap up, the very last thing, I promise this will be the very last thing, is uh of course, I hope that you're all attending Build in next week, but if you're using Copilot CLI, I don't know if you've all seen this really cool feature where you can use Copilot CLI to actually walk you through the session catalog for Build. So, if next week you plan on joining the conference, that is Microsoft Build, let me show you a quick hack that you can use. So, this is the Build site.

[01:15:11]It's build.microsoft.com.

[01:15:13]If you head there, there is this note over here, GitHub Copilot CLI, lets you run Build from your terminal.

[01:15:21]What does this mean? If I click on learn how to do this, it should redirect me to the Build CLI >> [music] >> repository.

[01:15:31]And I should have instructions here on how to run the Build CLI plugin.

[01:15:37]So, just because we can, I am going to do that. If we need to drop knowledge, I know I'm over time, but this is recorded. You can always come back and rewatch. So, I'm going to start a new >> [music] >> I'm going to start a new uh session.

[01:15:55]I'm going to open Copilot.

[01:16:01]Then I'll just copy this command here to install the plugin.

[01:16:11]So, it's {slash} plugin install Microsoft Build CLI.

[01:16:15]Right? So, we have the plugin installed successfully, and then I need to restart the CLI. So, I'm just going to do that.

[01:16:25]Um restart.

[01:16:27]And so, the idea here is that I can [music] type a prompt like what Build sessions are relevant to my project. So, if you ran the CLI agent from within your project, >> [music] >> then it's going to analyze your dependencies. it's going to analyze which technologies you're using, what's the nature of your project, and then it's going to use that to recommend some sessions from the build catalog.

[01:16:51]>> [music] >> So, I think that's a pretty interesting use case. So, I can go in with a prompt like uh do we have any sessions on GitHub [music] at on GitHub at Build?

[01:17:10]Oops.

[01:17:12]I'll send that in.

[01:17:15]And I expect to see the CLI agent here use the Microsoft Build plugin.

[01:17:21]Yeah, so it's pulling in the skill.

[01:17:23]>> [music] >> And it should be able to connect to the Build catalog, browse through the sessions, and then come back to me with a list of sessions that are relevant to GitHub.

[01:17:36]And this can be any topic of choice, any technology of choice. So, let's see if we are able to successfully get that.

[01:17:52]Okay.

[01:17:54]So, summarize GitHub sessions at Build.

[01:17:57]It's trying to filter and go through the catalog, narrow down to GitHub sessions, and I expect [music] to at least get a list of available sessions, and there you have it.

[01:18:10]Uh we have 36 unique GitHub sessions at Build. This will be a busy week. Uh so, you see the sessions with their codes and when the session will be these sessions will be happening.

[01:18:22]Uh you can at least you can go deeper into some of these sessions. So, this here [music] looks interesting. Your agents anywhere multi-client, multi-device. So, I can ask the agent to tell me more about BRK 206.

[01:18:42]BRK 206.

[01:18:44]This way it's able to just pull and have a back and forth with a build catalog and it can give me additional session details.

[01:18:52]And as I said before, >> [music] >> um Yeah, so this is a session. It's a breakout session, level 300. These are the speakers. This is when it's happening. This is where it's happening.

[01:19:03]This is a topic and here's an abstract.

[01:19:05]So I can easily just know which projects are which sessions I can attend next week at [music] Build. And then you can see this callout actually that given your project, so I've launched the agent in my key mask project. Now given this project, [music] this session is quite relevant. The Copilot SDK um is is going to be highlighted in the session. So you can already see how you can just work directly from your terminal, have it scan your project and then recommend sessions that you can attend that are relevant to what you're building.

[01:19:40]And then after Build, of course, you can go in, ask for, you know, what should be the next step of that after this session. You can ask it to scaffold new projects based on a session. So if you attend a session, you want to apply what you'll have learned, you can work with this um skill to scaffold a new project which which will just set you up for success as [music] you are implementing what you learned at Build.

[01:20:07]So with that, I will call it a day.

[01:20:10]Uh yes, this session is live and the recording will be available at the same link, so you can always come back and rewatch um later on. So this session will always be here for you to come back and [music] rewatch.

[01:20:25]Okay. Uh yeah, so for those attending Build again, happy building next week.

[01:20:31]We will likely connect on Thursday, either myself or my colleague. But yeah, with that I will call it a day. Thank you all so much for joining. Do enjoy the rest of your days.

[01:20:43]Bye-bye.