GitHub Copilot CLI – Your AI Terminal Companion

00:03|Rehab Ragab

Hello, hello, hello. This is my first session in this amazing community. So, hello everyone. Our session today is about GitHub. First, thank you. more Tarak and Odo for joining today and thank you, special thanks for Tarak for creating this amazing community. We're very happy to be part of it where we can learn and grow together. Thank you all. Let's talk about the terminal and the GitHub Copilot, which is your AI terminal companion. That gives you all of the power of GitHub Copilot directly in your terminal and so much more. So, a little bit about me: I'm Rehab Ragab, I'm A DevOps engineer and Microsoft MVP in DevOps, and this is the second year of I think is this amazing recognition, and I think I share I share this when I got the.

my second award in the community to celebrate this milestone together. I'm a community advocate. I like and love to be part of communities and love and passionate about sharing knowledge. And always say, if I know it, I want you to know what to say. So this is a session for today. Before getting started in the GitHub Copilot, I did dive for its features and capabilities. Let's ride in the waves this year where we are today. So, four years ago, generative AI began to fundamentally change software development. And that shift has come in three waves. And today we are living in the transition where Asians eventually become full-fledged team members.

So this shift starting through two, three waves, wave one, wave two, and wave three. So starting from wave one, the road along and help you write food faster as assistant or like a peer programmer. But the developer did all as driving and moving from wave one to wave 2 starting at 20. 2024 to 2025, which is Agentic SDLC Agentic Software Development Life Cycle, where agents moved from assisting and the build programming to participating as peers across all the development life cycles, starting from planning, building, and reviewing across the life cycle. So sometimes they are still living their tools in, and many business are already rolling out at scale.

And moving to web 3. Teams and the agent work together with the developer at the center directing the work. This is where the world is rapidly heading. So today we are in the shift from wave 2 to wave 3 from the bear programmer. becoming a true peer and the teammate with the football at the center. So, this is what GitHub has been expanding, not just the one tool in one place, but AI is at work is where developers already are. The core idea here is code the command and the cooperate. So Copilot is designed to support different needs, whether if you care about speed, about accuracy, about cost or flexibility, Copilot support all these needs.

It also supports ways of working. You can use the GitHub Copilot coding agent, and you can also use custom agent, third party agents, and the integration across the tools developers already use using MCP servers. So instead of thinking about the GitHub ProPilot as just autocomplete, you can think about it is a broader AI platform across the developer, as the entire developer software development lifecycle and workflow. So, GitHub Copilot, one GitHub one GitHub Copilot everywhere you put is available everywhere that you put and for any programming languages that you are putting in. So, if you are storing your code on GitHub on GitHub.

com, you can use GitHub as it's deeply integrated there, but also it's available anywhere else. You don't have even be using GitHub to use GitHub Copilot. You can use it. in different IDEs like Visual Studio, Visual Studio P, which is the premier code for editor for the GitHub Copilot. And it's available also in other IDEs like Eclipse, Visual Studio, GitHub, and many other IDEs. You can integrate it also into the mobile app, and here is, of course, GitHub, which is our focus today, and you can even delegate tasks directly from Slack and Teams or popular board of management software like Azure or\...

Linus. GitHub Copilot CLI. This is all just a quick introduction about the waves and where we are. And this is bringing us to our today's topic, which is the Copilot CLI as the command line interface for GitHub Copilot that allows you to use Copilot directly directly from your terminal. Just a side note that Copilot CLI is available through all Copilot plans. If you have a free plan, Pro, Pro Plus, or any other plans, you can use GitHub CLI, but\... If you receive Copilot from an organization, the Copilot CLI policy must be enabled in the organization settings to just allow you to using the GitHub CLI.

Some of the features and capabilities of GitHub here, as you may expect, is a bag of full of features, including interactive, as you can use it interactively in the terminal. You can also use it as a headless automation. You can use Copilot CLI in automation in your CICD pipeline or any automated task, and also as a system with the code generation, modification tools, execution, and the script, and the all of this feature. It can understand your entire code base, and also it's a multi-file context where there are lifecycle hooks and there are multiple modes. We will go through all the modes of the GitHub CLI, and also you can customize your CLI using.

custom instructions, skills, agent, custom agents, and you also can integrate it with other tools and the servers using the MCP server. This is one thing that we'll use all the time inside the Copilot CLI, which is a slash command. This allows you to do a specific task instead of writing. a prompt for this test. Like you can use slash agent to switch to a custom agent. You can use also slash mode to view all available slash model to view all available model and to choose which to use slash plan to use plan mode. We will go through this and we will see a live DOM about it, and our product remote to manage the remote sessions, delegate skills, dev review, all of this.

This is not all the slash commanders, but this some of them, and we will. dive deeper into some things you will use every day. One of the most important slash commanders is plan slash plan to plan a task before getting deeper into into into writing support for this task, but before before talking about this mode. Let's start with the interactive mode, which is the first mode of the GitHub Copilot CLI. As when you first get into GitHub Copilot, you will be in an interactive mode. This is the default mode. When you start the Copilot CLI, you will be in interactive mode, which Allows you to work alongside the agent to\...

11:35|Participant

I never saw this coming, I swear.

11:44|Rehab Ragab

Okay, so as an interactive route allows you to iterate on your work when you need to make changes or call a tool, for example, it will ask you for your approval and then it will continue on the work and make edits. But this is the interactive mode. There are other modes that are built in, such as the plan and autopilot mode, that enables you to work directly with a team of agents, of agents. And so, the first one is the plan plan mode, which allows you to create an implementation strategy before writing a code. So, this lead the code pilot on lies requirement dependencies. And the potential approaches, and whenever you are ready to implement this, the generated plan from copilot using this mode, the plan mode, you can switch into autopilot when you are ready to execute work.

with the manual interaction. So, interactive mode, this is the first one that you interact with, combined mode, you use it for planning tasks, and it will generate a plan before before executing it. And autopilot mode allows you to execute work, but with less manual interaction. So, you can use shift attack to switch between different blends, as you can see in this screenshot. OK, we know about with the different modes. Let's talk about with customizing GitHub. You can customize GitHub using the different. Different sections, like using custom instructions, using agent skills, and using the custom agent.

So, using the custom instructions allows you to define best practices and including and including the conventions. that the agent will use with every request. And the skills allows you to define custom instructions and tool access that hold on demand. So custom instructions for the agent, and it will hold for every request. But the skills is is for specific work and will be pulled on demand to do this specific work like front-end design or accessibility or any other any other. And also tasks or work, and in addition, this is you can use custom agent, you can create your and specialize your agent, like for exploration, could review task execution.

or complex tasks. So let's dive into a custom agent or agent at all. You can see here we have two types of agent, built-in agents and custom agents. This is really unique about the CLI. You, there are powerful agents built in directly to the CLI. The general agent is your coding agent and you give it a profit and it will go ahead and use the tools and tasks. to go off and execute them. There is another built-in agent which is a research agent to deep research to help you investigate about the issue or problem or understand the potential feature and it will create a comprehensive documentation for this research.

You can find also the plan agent where we talked later in the previous slide. This is in plan mode. This is the plan agent. that will create a full implementation plan. And it will ask you questions to clarify requirements. And once it's done, it create a fully, it create a comprehensive document and it's ready to fully implement exactly to your specification. Don't see this in the demo. And best of all, you can create, besides this built-in agent, you can create your own custom agent to specify exactly how you want the specific agent to work, what tools are available, what MCP servers as well.

So, you can create, for example, your own code reviewer or your your documentation generator or a GitHub expert is that you will work is that you work with directory inside the CLI and to create a custom agent, it's just a markdown file. It has two main sections. The first one is the front model, which you can think of it as a configuration for the agent. You specify the agent name, description, tools to use, MCP servers, and Only this configuration, and the second section is a agent instructions, where you specify your instruction for this custom agent to do the work that you want. You can also another interesting thing in the GitHub is built in the GitHub native integration, so GitHub can search issues, analyze labels and activity, and summarize.

scope, so you can move from backlog to implementation without context hunting. You can access GitHub issues at the project context directly from the terminal, moving from backlog to implementation without the switching between GitHub. and the browser and the IDM. So you stay in flow by bringing issues, issue contacts directly into the coding experience. So. Let's, and by the way, this is powered by GitHub Copilot. I, as I mentioned, built in MCP server protocol, but you can always extend the Copilot with your own MCP, not just the GitHub MCP. You can use. Your own MCP server, such as Azure, Azure, Subbase, Microsoft Learn, and many more tools to your toolbox.

So, what if you would like to have you work done remotely in the cloud with? So, this is for the GitHub Copilot coding agent. You can integrate GitHub Copilot coding agent. Using slash, this is another slash command, slash delegate, so slash delegate, delegate engineering work at any time directly to as a copilot coding agent. copilot can create a branch, implement the changes, and\... even open draft pull request in the cloud for you. So you continue working while the agent complete your task in the background. At any time, you can use another slash command, which is slash dev to see the differences between your code and Generated put from the this put in the agent, and you can use also PR reviews to inspect and validate generated changes.

Another interesting thing here is you can access, you can give access to the CLI and your machine from anywhere in the world. You start the internal, then monitors, tier and emerge from GitHub.com or from your phone. So to do it, you can use another slash command which is slash remote to access the running decision from GitHub.com or GitHub Copilot. and review output, respond to two prompts and approve permissions remotely, all remotely. So this is ideal for long running task. When you are away from your machine, the work will continue on the original machine. while you interact through a remote control interface.

Another thing here is the context. The CLI has a powerful context awareness. It has this concept of infinite session, which means you never really have to worry about the context. It automatically manage it. For you, so you can use slash command slash context to visualize the current context and where things are, and you can use slash compact, okay, to do compact manually and\... Mobile not also do come back to automatically. To and summarize, according to context, but because of infinite sessions, GitHub do it for you automatically. Also, GitHub Copilot gives you flexibility in which AI model power your session.

You can use slash model to switch between the front model from different providers like Microsoft, Open AI, Google. or any other providers. And also, if you have a preferred providers or model, you can bring your own key and you can also use the slash rubber dot slash command when you would like to get a fresh second opinion. It run a good reviewer with a different AI model rather than thinking or asking is the same model to review your own work. No, sir, but another thing is that you can do is specifically mention the code the files that you may want to be working on directly inside of a specific format, and you can even give it the images.

by dragging and dropping it or passing it directly into the CLI and it will then use Vision API to understand that image and also it can read those files directly. So that's really important when you would like to mention files as a context for your prompt and it's a nice way to guide the agent into what you need to have done. The last thing here I would like to talk about is you can be running multiple and parallel mobile sessions all at the same time. You can have multiple tabs, for example, multiple terminals open. You could you could be running in background task agent, as we mentioned, inside of Visual Studio Code, as either interactively or in the background, or using any other IDE as well.

You can run all of the all of this at the same time across multiple code bases. And this is just scratching the surface of the CLI. So I think enough talking, let's go for some demos. So we'll start by see how to install GitHub Copilot CLI. The installation is available across all operating system. You can install it Windows, Mac, or Linux, and you can install it with common tools like WinGet, Homebrew, and of course using the npm as well. So, let's start by seeing this in action. So, here, let me\... Uh, share. So, please let me know when you can see the demo running here. You can see it now?

Okay. Okay, thank you. So, getting started to installing the GitHub Copilot CLI, I will, as I mentioned, you can use the WinGet for Windows, you can use Homebrew or

27:19|Participant

Yes.

27:37|Rehab Ragab

Or you can use npm for all operating systems. So here for this demo I will use npm. So I open here Git Bash. And just verify that I have node and the npm installed successfully. So typing the version and to install it, just type this command, the npm install the G at GitHub slash Copilot. So, it will start installing it, as you can see here. To start to start the GitHub Copilot, just type Copilot and this will enter you to this interactive. As I mentioned, there is 3 modes: interactive planning and\... interactive planning and autopilot. This is the first mode which is the interactive mode. Once you tie up copilot, you in the interactive mode where you can interact with copilot directly.

To get your task done, so first, in your first time, it will it will ask you if you trust this file in the folder or not, so type this here. And to start, I need to log in to my GitHub account. So I just type slash login. This is another slash command slash login to log into to Copilot. And it will ask you if you would like to log in into GitHub, github.com or GitHub Enterprise. In my case, I will use GitHub.com. And once you hit enter, it will give you one time code to just verify and start logging to your account. So here I will continue. And the type is the code that I\... And just authorized.

And backing to the command line, as you can see here, signed in successfully as this is my GitHub handle and GitHub MCP server that I mentioned in the slide. This is the built in MCP server in GitHub. So one server connected and just verifying that everything is working as expected. Just saying hello and tell me what you can help me. It will, here, as you can see, it says the checking my documentation, GitHub documentation, and just replying to your prompted by, hello, I am GitHub, powered by the models that I choose for this session. The answer that I can help both software engineering tasks and all this.

all this reply. And if you would like to end the session, you can just hit another slash command slash exit to end the session, this interactive session. So another demo here. Is about it, just I need some yes here. Another demo is about the second mode of the Copilot CLI is plan mode, which you can use to plan your task. So to start the planning mode, you can type Copilot slash slash plan to enter the plan mode. Instead of copilot, just to copilot, give it this switch dash dash plan, or even you can, if you are already in the interactive mode, you can use slash command slash plan to switch to the plan mode.

So I will use search plan here and give it to my prompt to plan the task here. This is my repo and just a simple application, a book application. I asked her to plan for adding search and filter capabilities to As a book. So, here it will start by\... Searching is a good base. and searching for standard and the custom instructions inside my repo. And it will ask, as you can see here, it will ask some questions for you to know how exactly write the plan for this task. So here I ask it no, should Should the search and filter be two separated the task or? But here, all one combine the commands, so I hit the option I would like, and it will create planning for this test, and the plan is ready, and it will ask you if you would like to start.

implementing this plan using the autopilot mode or if you would like to accept it and build on default permissions or exit plan and you will prompt yourself. So I here I just exit and it will create a markdown file inside this location which is here. Here, inside the home directory of your user here, there is after installing GitHub, this, you can find this is the folder inside the home directory, and inside that you can find another folder which is the session state inside the session state. Here, this is my session. You can find the plan, the plan markdown file for the task. Here is a plan title, add search and the filter to book app.

And you have a problem, what is the problem, what is the approach, and also Notes for implementing this plan. So, here, as you can see\... So, as you can see here in the notes, you can find follow dot GitHub slash instructions by standards instruction dot MD. I mentioned that you can customize the GitHub Copilot using the custom instructions, agent skills and creating a custom agent. So, this here. by some standard instructions. This is a custom instructions file inside my project to give some instructions on how to behave and to put in the standard and so on. So, here, as you can find in notes, it tells to follow the standard.

the custom standards that I created inside this locations to all new function signature. So if you go and start implementing this plan using the autopilot mode or interactive mode, it will follow this notes that listed here in this plan dot MD generated file. Another another mode, this is interesting for me, which is the programmatic mode, where where you can use the GitHub Copilot in your CICD or any automated. The test, so I just did this use case for demo, but it's interesting. I have a blog post hosted on GitHub pages for free, and I thought about it just why not using GitHub Copilot in my GitHub action work.

Flow to review my my proposed, so whenever I open a new pull request, GitHub, I act as a technical reviewer and give the. and give me a report of the findings and trends and what sections should be improved and so on. So here this is my GitHub Action workflow. Inside here, I just add a new step here. to just name it the review blog post and the run Copilot dash B, which is the programmatic mode, and and here define my prompts. So here, like, as you can see, act as a senior technical editor reviewing this article before publication, read the entire article and evaluate. technical accuracy, readability, grammar, structure, and organization, as CEO, for example, missing explanation, beginner, friend, whatever would you like to review, just list all the pointers, and even you can list the output, how should the output be?

Inside your prompt, and here, as you can see here, and whenever here I open the pull request, this this workflow will running, so here it will install. And they will start reviewing my blog post. If\... And it will generate, as you can see, display review report. And to see the report navigating here. This is the generated report, AI technical review. This is one of my blog posters on how to become a Microsoft MVP. So it gave it the overall score, 8.2. over 10 and just give a score for each items that I mentioned in the prompt with technical accuracy, readability, grammar and writing and all these things.

And give a summary, strength, weakness. Suggested improvements. missing the topic diagram and so and all these improvement sections. Another use case on how using the GitHub Copilot and all you can using it for coding review. So here I will start to a new interactive session. And ask GitHub to review this file, book under score for code quality. And this type of reviewing is prompt review. And we'll see another type of viewing, which is using or invoking a built-in agent for viewing tasks. So here it will start by using this custom skill, put the skill, put quality skill and write As the output, as you can see here.

So, it will list the code quality, what paused and what failed, and what about input validation, what paused and what failed, what about testing, summary, what the most item should need attention before merge. Here. And this is the output for viewing. Another reviewing for embed validation, you can. Go with reviewing by specifying the specific items. For review. This is another. Use case. Let's see how to use. Yes, this is the second reviewing type of using slash review, which is built-in coding agent, no, no, review agent, run code review agent to analyze the changes. So here slash review. And if you would like to give the specific instructions, if not, it will just start reviewing.

The Changes. And review the changes. And Ron types the summary of the reviewing. You can also use the GitHub for generating tasks. This is another use case, the last one, I think. So, here I mentioned as the file I would like to generate the task for. And this is for, and just like my just there is an error here, just a second. Yes, here I asked the mentioned and at this my file, I would like to generate the test and ask to generate a comprehensive byte test this including test this for and just listing what test cases I would like GitHub to generate this for adding books, removing books, finding by titles, finding by author, marking as read, educated with empty data.

Just list all what you want and the mobile will start by generating. This is for your scenarios. So, here, after generating the test, it will run the run test test to make sure everything is working and all test devices. Here, this is the generated file in just a few minutes. So here, let me run the test test to make sure everything as I expect. So I will open new terminal and just navigating to my project and run Python. Dash M. by test and all this deposit post and everything as expected. So, here navigating to the slides. Yeah. Where is the, let me? Share my side again. Just a second. Yes. Yes, you can see, you can see the slides now, right?

Okay, so. Yeah, as as as I as I mentioned that this another this is again a good look again to the core features of GitHub Copilot CLI interactive assistant, as you can as we have seen in the demo. When we start the session, you are in the interactive mode and you can start interactively, contact interactively with the compiled CLI, ask questions, and just to get your task done. And you can also use it in automation as we have seen in the demo. I use the GitHub Copilot CLI in my CICD GitHub Copilot GitHub action workflow and code generation modification using it across all the development life cycle planning.

You can use plan your desk using the plan rule. You can using generating code, coding review, refactoring, generating the test, and also you can customize it by using custom instructions and agent skill, and you can create your custom agent, and also you can interact with the\... Tools and servers using MCP server model context protocol, and that's it for the session. It's a quick, a high-level overview. It's a high-level overview about with the GitHub and. The features and the capabilities, and if you are interested, then we can head down those sessions that going deep, deeping through these features.

So, thank you, and if you have any questions, Happy to hear. Thank you. Okay. Okay, so let's stop the recording. Thank you, thank you.