Name: Copilot in Action: Best practices & use cases
Uploaded: 2026-08-12T17:01:07.452Z
Duration: 45 min 19 s
Description: Copilot in Action: Best practices & use cases

Transcript for "Copilot in Action: Best practices & use cases": Good morning, everyone. Thank you for joining us today. We are going to be doing a short presentation in Copilot in action. What are some of the best practices? What are some of the use cases? And, you know, what you can do with Copilot in your organization. As more people are coming in, actually utilizing the poll, which is nice to see, I'll just do a quick short introduction for myself. Hi. My name is Rizvan Rashik. I am a GitHub solution engineer here, at GitHub, and I'm going to be showing you some of the use cases around Copilot, what are some of the things that we see enterprises utilize Copilot for, and a quick demo on some scenarios that, are valuable to implement. And alongside me, I have Russel who can Hey there, folks. Yes. It's Russel, another solutions engineer here at GitHub. Mostly here today just to kinda help folks, answer q and a, and make sure we're we're, like, engaging with everyone as much as we can while we while we go through this. So, you know, we'll be giving the demo. I'll be I'll be trying to answer questions there on the back end. And then towards the end, we'll we'll come together and, try to answer any more that come through. Awesome. Thank you, Russel. I'll go ahead and share. Awesome. So we went through what what the session is, what we're going to be doing, and we're gonna be now jumping right in. So why this session? We wanna use this for teams that are already using Copilot and looking to get more value from it every day. Essentially, you know, a lot of the sessions that we're gonna be doing, this will be really in related in relation to teams that are currently using Copilot, that are maybe beginner or intermediate level, and they wanna utilize, and they wanna utilize some of the other features of Copilot that maybe you've not heard of. We're gonna see, you know, some actionable steps that you can take to apply in your own organization, and we're also gonna go hands on with the Copilot CLI and the Copilot code review feature. So we're gonna talk about what that is, how that works, and what are some of the kind of best practice and use cases around those. Now I do see in the poll that, you know, a lot of the users here are very either, you know, beginner or intermediate level. So you're the perfect session so we can go through some of the steps that you might have not seen or something that you're currently trying to implement. Awesome. Next, what we're going to talk about is you have Copilot, which is great from a developer's perspective. But from an enterprise admin perspective and from an organization's perspective, how do I actually manage Copilot? How do I make sure that teams are paired with the correct licenses that they need? How do I make sure that there are guardrails guardrails in place so that teams can actually utilize Copilot correctly without going over, you know, any sort of budgets that have been set? And how do I make sure that, you know, we see actual adoption, acceptance, and overall usage of Copilot? These are all things that are important to, these are all things that are important to your, organization. And these are there are very much a lot of controls, that we can utilize and see. So as you see here, we have a question come up is, you know, how would you most like to use AI in your work? So this is really to kind of facilitate and, guide this demo on what are some things you might like to see. So as you, you know, do some votes, we'll kind of talk around those types of scenarios. Cool. So next, what we want to do so we talked about org wide rollout. What does that mean? What does that look like? Next after that, what we're going to be doing is we're going to be talking about governance. So a little bit about that is how do I manage access? How do I manage features? How do I ensure that if I don't want certain content, you know, being seen by Copilot, what can I what can I do to protect those guardrails? How can I effectively put that in place? Alongside that, you know, what are some things that I have in place for me to check, you know, who's using AI responsibly? How do I check that who's using AI responsibly? This is not just like a dashboard, you know, where you just where you go and, you know, see what's going on. It's more so these are some practices that we can enable to the developers and also enable at the organization level. So we can have clear cut steps as to what's the use case of AI, how do I use Copilot, and what am I going to do with Copilot in this organization? Next, we're gonna talk about best practices that stick. So what are some of the habits that separate, you know, casual Copilot users from users that see benefit and high quality output? So are they using, like, skills? Are they using agents? Are they using custom agents? What are some of these terminologies? How do I make sure that I use Copilot in, with the right context, with the right files? So we're gonna go over that. We're also gonna go over a scenario where you're a business owner and you find that you've provided a 10% discount, but your code is actually not, sticking to that model. You're seeing that, hey. I am getting charged 20% discount. So me as a business, I'm actually losing money. How do I go from figuring out that issue? How do I go from, you know, just having somebody complain to an actionable step that I can take, across kind of my software development lifecycle. So whether it's the analyst or whether it's, you know, somebody who's reviewing the customer complaints, how do they use Copilot and create an issue for the engineering team? We'll go through that flow and, showcase some of the best practices that stick and also what are some of the, you know, common scenarios and common themes that we see across different enterprises. Then after that, what we're gonna do is we're gonna look at the Copilot CLI at work. Now what's great about this is we're actually going to be utilizing Copilot c CLI in a different app, which is called the GitHub Copilot app. This brings all the functionalities features of the CLI in place, but it gives you a nice little GUI to look at and kind of, act as kind of like a orchestration control. So that's the place where you can kick off your automations, where you can set up your MCPs. You can set up, all different types of customizations that you want to do. After that, we'll be going over Copilot code review. So what is Copilot code review? How does that work? And what are we going to do with Copilot code review, from just the local standpoint and then also in the cloud? What does that look like in both environments? So we'll go over that, why it's useful and, just kind of what it looks like in practice. Afterwards, I just want to talk about, you know, your next thirty days. So what does your next thirty days look like after we run through this demo? And, you know, what are some things that you can do to facilitate your demo and or to facilitate Copilot, organization wise and across your enterprise. So some of the things that we can do is we can, you know, pick, like, pilot teams to kinda, showcase the advanced features or pick teams where, you know, you want them to enable Copilot and run with it as needed. So really just give you some actionable insights as to what you can do, what are some of the things that we might want to do, and then go from there. Awesome. So we got through the slides. This is a great milestone. I don't know about you, but I don't like slides that much either. So what we can do is we'll take a look at some couple of the poll questions and then kind of facilitate our demo there. Awesome. Thank you guys for voting. So as I see, a lot of the interest is around reviewing and improving my work. So peer review. So how do I do that? How do I use Copilot as a peer review machine? And then how do I automate repetitive tasks and workflows? Awesome. Given that context, I'll go ahead and share my screen, and we'll go through a quick scenario of what's happening. You know, what is, kind of our goal, and I'll kinda show you what repositories we have and how that relates to some of the best practices that you see. Cool. So I'll go ahead and share my screen. Awesome. So before we begin, if this is your first time seeing the GitHub Copilot app, this is what it looks like. I have a theme on it, so you might see it a little bit like kind of like a dusty color, but you can always change all of the themes. It's customizable just as GitHub is, so so you can always change these. I digress. But, yeah, this is the GitHub Copilot app where you can see kind of a UI version of the GitHub CLI. So this is essentially your terminal where you can ask Copilot any sort of questions that you want. Here, you can add files or folders for context. You have different modes that you can enable. So what's nice about this and especially with Copilot, when we talked about the governance piece, so what are some best practices that we want to do? What are some of the things, you know, that we care about? This is essentially some of the things that you can kind of enable across as a plan. So not everything needs to be autopilot where you have end to end execution without coming in to, you know, validate what's actually being prompted or given to you in an answer. You can have the modes be interactive where you're actually going through step by step, approving the next step that's coming in. Or what I like to do is you can set a plan first as to what you want to actually showcase and how you want to do that work. Then what we have, which is the nice part of this, is how do we optimize our costs? So as a developer, you know, you just wanna use the latest and greatest, and that's that's great. We can pick whichever model, and doesn't matter if I wanna open a file or doesn't matter if I wanted to build me the entire application. I'm just gonna pick a model that's the best and go for it. Well, as an enterprise, you might not wanna do that, and you might wanna think about cost effectiveness and cost efficiency. Right? So that's where this kinda comes into play. And what you can do is select the auto mode, which essentially picks the best model for each one of the tasks, and it will try to look for, you know, how can I get the best quality, reducing the most amount of cost? And you can pick this mode by default, or what you can do is you can not pick auto mode. And if you have some specific use cases, pick whichever model you like. So with GitHub Copilot, as you know, we have multiple models available from different providers. So you can, you know, use something from Cloud. You can use something from Gemini, GPT, whichever, you know, you want to utilize. Cool. So I'll pick auto here. Next, what we have are agents. So what are agents? Think of an agent as a specialized worker. So if, let's say, that I was in a restaurant and I had to think about Copilot in the context of a restaurant, I would say that agents are specialized workers like chefs, waiters, waitresses, store managers. They can put on different hats and act as different people that you can assign tasks to. So why would I use an agent? What's what's the benefit of it? So let's say that you want your agent to do something very specific. So you want an agent that is, you know, really good with compliance. So you want somebody to look at it from the lens of a compliance auditor. You can set up agents to do that where they have specific skills, they have specific context of what they're looking at, and they're going to be looking at it from the lens of that particular skill set that they have. So if we go back to the, example that I gave for the kitchen or for the restaurant, I mean, essentially, you can think of, like, a, cook who specializes in cooking Italian. You can come in here, pick the agent for, you know, the Italian cook, and they'll know exactly what ingredients, what recipes they might need to cook a dish, in the Italian way. So you can kind of think of agents such as that. Awesome. Then as we see here, we can actually link, any of our terminals or prompts to particular repositories. So what's nice about Copilot, the Copilot app is that you can either start a session that's automatically connected to your repositories, or you can either, add the project locally from a folder or from a local repository. And that's awesome because it will automatically get all of the context in the folder or automatically get all the context in your repo so you're not having to give it, you know, very specific instructions as well. Alright. So I digress. We came here. We looked through what the terminal is, what this looks like in the go GitHub Copilot app. Next, what I wanna show you is just some of the features that are available and what we're gonna be utilizing. In the GitHub Copilot app, you can make use of MCPs, plugins, skills, extensions. There's a lot of customizations you can do, but just at a high level, MCPs allows you allows you to use external tools and their data. So for example, for me, if I wanna get data from Slack, I can go ahead and do so. WorkIQ is where I can look at my emails, and this will give me, all of the information there using my credentials. Skills, they're very particular set of instructions that kind of define what, what the AI can do and how to do it. So you can think of skills kind of like a method in your funk, in your class. So if we're talking like, you know, as developers, you can think of skills as methods. You can think of, you know, MCPs as just like different databases that they can look into, and you can think of plugins as sort of an extension of that database. Cool. So there's a lot of customizations available here that you can utilize in the GitHub Copilot app. Next, this is where I want to talk about some of the automations that you can do. So what we talked about, earlier, which is around, you know, what are some of the repetitive tasks that we can, stop, and what are some of the repetitive tasks that we can automate, here's a place where you can come in and create templates for automation that you might want to do. So for example, I have this issue triage automation. What this does and if I go to edit this, what this does is every day at around nine my time, it will review the latest GitHub issues and propose prior priorities and owners of those issues looking at this particular repository. So every day, it'll come in, give me a quick rundown of all of the open issues, what's the proposed priority order of where and how I should review, those issues and prioritize what goes first, second, third. And this is great because this gives us a lot of context as to, you know, what your workday might look like. Something that's also useful is that, you know, you can have these run daily or anytime that you want. Alongside that, if you wanted to, for example, create automations that are very specific or manual in this case, you can do so. So for this, this is a demo automation that I created. Essentially, what I want this to do is I want it to search my inbox for any email that contains any sort of complaints from a customer for my Copilot demo. What this will do is this will look at my email and try to find any sort of issue. And then, after it finds a issue, it's going to give me some actionable insights as to what I can do. Awesome. So now that we have that, let's actually put this into practice. So if I have this demo email taster solution, I go ahead and run this automation. I'll open it as a session. What this does is this will show me exactly what's happening. It's gonna use my Copilot demo store as the repository in which it, finds that issue and facilitates, you know, what it should look like. As you can see, as this is running, this is just essentially WorkIQ, going in and retrieving the actual data from my email. So it's scanning my emails to see, is there anything that I find that is, in relation to the query that I have here? And it's going to be showing me, you know, what are some of the findings there. Now as this runs, I do want to showcase one thing. This is a, like, individual session that's running under the Copilot demo store. Let's say that I wanted to create, like, another session. I can do so. I can come in here, create a new session, have this independently run against my Copilot demo store, but I can also come in here and, you know, have I can I can have, some other tasks that I wanted to do? So for example, if I say, can you list both the issues for this repo? It can do so. Awesome. So now that it found a customer complaint so going back to kind of our demo scenario is that, you know, hey. Like, you know, there may be some actionable insights as to what to do. So, I wanna see what some of that issue might be. As you can see here, it created some actionable insights as to what a, issue might be. It looks into my inbox and sees, okay. I found a relevant issue. I'm gonna create a particular, complaint for it. And this shows, you know, what some of the impact, what's the summary, what's the root cause, you know, hypothesis, and what some of the proposed fix and acceptance criterias. So what's great about this is that this will look for, all the issues and give you a draftable, you know, kind of like a exact draft of what you want. Why I say that this is an exact draft of what you want? If we were to open up the files here, we actually have an issue template. So we have a bug report that says, like, hey. I want you to report certain types of issues in this particular way. So it looks at it and gives you, it'll give you this sort of clarity where once it finds a bug, it'll create this new issue and go from there. Now what I want to do is I want to show you that in real life. Once that draft issue has been created, what does that look like in the IDE? And then what does that look like, in terms of remediating the issue? Cool. So now what I'll do is I'll go ahead and stop sharing my screen, and we're going to head over to our actual repo. Okay. Awesome. And we should be able to see my screen now. Cool. So I've already created this issue here from prior run, but I just wanted to show you what what it looks like, when it is found awesome. So what this issue is, what what happened, It we found that analytics flagged a discount rate anomaly starting at this particular range. Essentially, what it's saying is that, hey. A lot of our discounts, it didn't actually provide the right discount, and we actually lost a lot of money. So what are some of the things that we found here? Or well, we found that, you know, the expected behavior was not correct. This is something that the analyst team has shown us, and we wanna actually go ahead and fix this particular issue. So the way that we take this issue and fix it is we're going to go into our repository, and we're going to we're going to go in and enable Copilot to take a look at this issue and get all of the fixes in place. So I'll stop sharing my screen here. And what I will do is we're gonna go over and showcase our GitHub Copilot app again. And we'll do it here. Okay. Awesome. So you should be able to see my screen now. So I created this before. Essentially, what this is is this is saying that, hey. I want to use the revenue anomaly skill and investigate the checkout data. So that issue that you just saw that was created, this was using the anomaly skill where an analyst came in, use the skill that was predefined in the repository, and then it is being, and then this is being investigated and showing an actual summary. After that, once you know what the behavior is, once you know what are some of the recommended next steps, this is then showing, you know, like, how you can create the GitHub issue within the Copilot context. So you can say it you can say for this session that, hey. I wanna create the GitHub issue for the engineering team, and, specifically, I wanna create it in the Copilot demo store repo. Here, how did it come up with some of those instructions? This is going along the lines of governance and going along the lines of, you know, what are some guardrails in place and things that we can do to help facilitate, you know, making sure that our outputs are the same, we can make use of something called instructions. So Copilot instructions. This is a repo, where, we'll have certain conventions, we'll have certain guardrails in place. Essentially, you can think of Copilot instructions as your first step in creating, kind of rules that you want to follow. And alongside that, what we wanna show is these Copilot instructions are something that you can use across your repositories. They show what are some of the conventions that you, like, you want to follow within your context of every single, GitHub session that runs. So any chat system that you run, it'll go ahead and use what's written in the Copilot instructions first. Then what we can also make use of are skills. So as we mentioned before, skills are very specific to, you know, what are some of the steps we need, to go in and, you know, facilitate an issue, figure out what's going on, and how to actually, you know, work on that issue itself. So here, you'll have, this particular skill. It says that, hey. I wanna analyze what was happening, interpret what's going on, and then produce an incident report with the executive summary, evidence, impact, and also draft the actual issue. So because we've, you know, reduced the amount of context that it needs to look at and also, gave it exact steps of what to do next, this is something that's reusable that you can utilize across multiple different teams, multiple different use cases, and something that is easy to, use, across the board. Awesome. So we found this issue. We have a, we have a particular issue that we wanna work on. What does that look like in practice to fix that issue? So I'll go ahead and stop sharing here, and we'll go over to my code base. Okay. So here, I've come in into my Visual Studio code. I have my GitHub Copilot demo store, already in place. And what I want to do is I wanna make use of different prompts that are available. So prompts are reusable commands that you can use to say, like, hey. What do I want to do? How do I want to do it? Give me an exact structure of how this is going to go. So what we wanna do is we wanna make use of these prompts. So I wanna say that, hey. Investigate my issue. And what this will do is this will investigate the issue and then figure out what are some of the what are some of the things that we can do to mitigate them. And I know we're a little bit over time, so I'll I'll tryna, you know, go, go over this a little bit quick. So here, as you can see, this is interactive. So this is going through my issues, looking at what it's going to do, but it this is all within the context of the CLI. Awesome. So here, it found that, you know, hey. My issue, I I know exactly what it is. I also know, how this, you know, how this is affecting my behavior. So the effective discount was not 10%, but it was 19%. So it tells me exactly what some of the minimal fixes are, what can happen, and then what it can do later to actually fix it. And what we can do and I'll go ahead and open that up quickly, is I want to actually fix this issue. So I can say, can you implement the issue that you found and then provide a solution and a PR for the particular fix. Awesome. So what this will do, is this will say that, hey. There's some, changes that I made. There's some tests that are now passing. Do you wanna keep the changes that are already there? So I can say keep. And alongside, you know, actually implementing the fix itself, what we see is that there are different agents that we can utilize. There are different prompts that we've also utilized. All of these, as you see, they're kind of put into the prompts itself and also in our Copilot instructions. So what are some of the project conventions? What are some of the guardrails? And what, you know, done looks like? Cool. So next, what we can see is this is actually pushing up the fix and looking to see if we can automatically create the bug fix. And we love when there's authentication issues. Not a big deal, but we can always, you know, pull and push. Great. So we push this up. We've seen, you know, kind of how the Copilot instructions work, what are some of the prompts, what they do, how they do it. And next, just around, you know, agents, what they are, how they're utilized. Next, what I wanna show you is just one last thing, I promise, and then we'll go into q and a. Okay. So I'll go ahead and stop sharing my screen here, and we will bring up the PR. Okay. Awesome. So let's go into our Let's go into our PR here. Alright. So this is the last thing I wanted to show you. So we went through the steps of identifying an issue, looking at it from our emails, how we can use the GitHub Copilot app to automatically create an issue based off of the email findings. Next, we went over what some of the agents are, skills are, prompts, why you'd like to use custom instructions, and some of the guardrails that you can put around it. And lastly here, we are gonna go over and talk about Copilot code review. So as we saw with our last iteration, we fixed the issue, put up a PR, tested the actual issue with a regression test that was there. Now I wanna actually create this pull request. And when I create this pull request, what I can do is I can actually have, Copilot review my pull request. So what Copilot will do is and this is the ability called Copilot code review. Copilot comes in, takes a look at your PR, checks for mainly quality, any sort of, anything that it can see where, you know, it might be beneficial to fix or beneficial to call out, such as, like, if you're using, like, an infinite loop or something like that, or if you're using some sort of, standard that might be deprecated or something that might be useful later on, it comes in and can do a review for you and tell you exactly, you know, does everything look good? Does it not look good? And you can actually view the session here to see what it's actually doing. And what's nice about this is that anybody that is within your repository, they can actually come in, take a look at these agent sessions, see what actually happened. So everybody gets the context, that you want to use and see. Okay. I know we went over a lot, and we went over, you know, kind of the different features. Now what I'd like to do is we're gonna stop sharing the screen. And I'll just take a look at some of the questions and answers, and maybe we can, you know, answer some of the questions that are there. Awesome. So and thank you thank you guys for all the questions and also, you know, some of the questions that you have, around Copilot. So some of the first things that I see okay. What is the difference between this and the GitHub Copilot inside Visual Code? I see automation option is not there in the Visual Code extension based GitHub Copilot. Great question. So you can think of the main difference between GitHub Copilot and the GitHub Copilot chat session that you have and the GitHub Copilot app. The GitHub Copilot app is kind of your, like, your control center. So you can think of it as a orchestration layer where you can, set up automations to check your emails, to set up automations, to run, you know, chat sessions against multiple different repositories that gives you, a lot of these, that gives you a lot of the features. Basically, like, a lot of the features that are being enabled on that repo. You can get context around the repository itself. So you can think of GitHub Copilot app as kind of like the place where you orchestrate what you're going to do, how you're going to do it, and get visuals alongside, you know, what the implementation strategy might look like. The the Visual Studio Code extension based GitHub Copilot, that's essentially just the Copilot chat session itself. So pretty much what will happen is you will see the actual, you will see the actual GitHub, implementation of what you want to do within the Visual Code session itself. So, essentially, you can think of the Visual Code chat session as your implementation window, where you can go in and do the implementation windows, where you can do go in and do the actual implementation itself. And you can do that locally or in the cloud. You can look at the GitHub Copilot app as kind of your way to not just look at one repository, but you can look at a plethora of repositories. You can even look at things outside of the repo itself. So something where you can, you know, like, have other automation in place that's not just, you know, looking at your, repository code and trying to do x, y, and z. Okay. And another question that we have from Wang Fu. Okay. I joined about five minutes late. Didn't see the beginning, but how come this Copilot app really looks different from the Copilot agents in Visual Code? Awesome. So why this looks different from the Copilot agents in Versus Code is because in the GitHub Copilot app, you can make use of, agents across your workspace. So whether that be, you know, agents that have been given to you, in your in your repository scope, whether they they have been given to you at the organization level, or whether they're, agents that are available to you at the enterprise level. So you have more availability of, you know, different agents that you can utilize, not just the local ones that you create. And the next question, that might be useful is what is the difference between an automation and a skill? So that's a great question. Automation is something that is in the GitHub Copilot app itself. So it's something where you can think of it kind of like a cron job. Similarly, how you have a cron job where you can, you know, have scripts with certain steps in what they do. You can think of automation as kind of like that cron job with a specified prompt that you want GitHub Copilot to run. So what a skill is in regards to that would be how do I, you know, do the thing that is written in the prompt. So what that might look like is I might say that, hey. Go into my emails and gather, the emails that say demo. Well, okay. I I know that my task is that I want to go in and gather the demo, but how do I actually do that? What do I use? What tools am I going to use? How how is that gonna be facilitated? That's where a skill comes into play, where the skill will go through step by step order of what that process looks like. So step one may be, hey. I need to use the MCP server. I need to make use of I need to make use of, you know, different tool sets that are available to me. And I need to make use of, you know, different guidelines that are in place before I go get the email. So for example, I don't wanna, like, touch any email that have a sensitivity label of sensitive. Those are different things that you can define in a skill. So the skill, you can think of it as the how to of what I'm trying to do, and then automation is what I'm trying to do at what specified time. It can either be manual or it can be triggered on a timely basis. Okay. Great questions. Something else that I think, and some of the other questions that I see here. So we'll go through this. Okay. Cool. So what KPIs or maturity indicators can be used to evaluate an organization's copilot journey from basic adoption through advanced usage patterns such as MCP, integrations, custom skills, and agent based workflows? That is a great question, and this kinda shifts over to our enterprise, governance, kind of mindset and ideology. Right? So what KPIs are maturity indicators? Well, what you can do today and I'll share my screen just for one second. Sorry, guys. I know I said I wouldn't, but we're just gonna do this because this is a cool topic that we can talk about. If you can see my screen here so addressing your question around Copilot IDE usage or or not Copilot IDE, but what KPIs. So you can think of it like this. I have Copilot rolled out. What's the usage of KPI? How can I justify this to management? You know? How do I see, if users are actually using Copilot? How many active users do I have? Do I have agent adoption across the board? Well, you can come in to this insights tab in your, organization level, and you can actually get all the metrics that you might wanna take a look at. So here, we'll see all of the metrics that are available to us, that talks about code completions. These are things that were generated by Copilot. How many of them were actually accepted completions? You know, what's the rate of acceptance? Which models are being used per day? There's a lot of metrics that you can look at and see, you know, some of the value and kind of get an understanding into what's happening within your organization. Alongside that, something that I kind of like to show, what's the impact of Copilot? So literally exactly what you're mentioning around adoption. There are a lot of passive users. How long does a median merge take? How long does somebody who is using code completions? How long is their median merge time taking there? How much code is being shipped? All of these all of these things are available to you under your Copilot impact metric. So this is something that you can take a look at. These are also some metrics that you can utilize to show, like, kind of the KPIs and go from there. Awesome. Now the last question, I find the CLI much more efficient on my hardware and with all the security things installed and Copilot installed, it starts to slow down. Can I do automation in the Copilot CLI? That's a great question. So, yes, the short answer is yes. You can do the automations in the Copilot CLI. The long answer would be that when you do set it up in the Copilot CLI, you have to do, a little bit more kind of a kind of a, like, a setup of what MCPs you wanna use, what tools you wanna utilize. You have to set those up ahead of time. Cool. Alright. So I think we're at the end now. If there are no more questions, I think most of the questions have been answered. Yep. That was pretty much our session, and, you know, thank you again for joining. And, hopefully, this was helpful. I know we did jump around a lot and go from one one stage to the other, but, yeah, hopefully, it was helpful. And, any questions you have, you can reach out to our team, or you can always, you know, send us a message on GitHub, any of the community sessions or anywhere else. Alright. Thank you, everyone.