The way we do our job is changing fast. With the rise of AI-assisted development, tools like Claude Code and GitHub Copilot are no longer just autocomplete engines inside your editor. The Copilot CLI brings that same intelligence directly into your terminal, turning commands into workflows.
In this post, we’ll explore what the GitHub Copilot CLI is, how it works, and how you can use it in your daily job. From generating shell commands and explaining complex scripts to speeding up debugging and development.
Installation
To use GitHub Copilot CLI you need a GitHub Subscription. You must have an active Copilot Individual or Business subscription, or access through organization account.
Simplest way to install the tool is to run NPM install command in your terminal. I recommend to use the prerelease version as it has a lot more features available than the regular released version.
npm install -g @github/copilot@prerelease
After running the NPM command just simply type copilot to terminal window. This launches the GH Copilot CLI app and during the first time you need to authenticate using your GitHub account.
Basic Usage
In most basic usage you can just type questions into prompt and the AI will answer to you. You can also use / -commands to setup the CLI environment. Start by taping /help into terminal. This command printouts instructions on how to setup permissions, use sessions, change model and so on. On thing to note is that GH Copilot CLI is not “regular” terminal app. You can navigate up an down in selections, you can cancel operations, etc. It is more like a normal graphical UI than terminal UI in a sense that it contains wizards to setup things, dialogs etc.
When you type copilot the app starts in that folder where you were. So it works within that folder context. That’s why you need to first navigate with cd commands into folder that you want to work in. App supports multiple instruction files, but I prefer to use AGENTS.md file.
AGENTS.md is a simple markdown file that contains instructions for agents. For example you can describe your runtime environment, what kind of folder structure your project has etc.
Here is an example of an AGENT.md file for C# projects. If you are more making a definition then you want to describe your environments in this file. You can also refer other files in this markdown files. For example if you have a database structure in another markdown file you can add “Database schema is located in schema.md file” into AGENT.md.
--- description: 'Guidelines for building C# applications' applyTo: '**/*.cs' --- # C# Development ## C# Instructions - Always use the latest version C#, currently C# 14 features. - Write clear and concise comments for each function. ## General Instructions - Make only high confidence suggestions when reviewing code changes. - Write code with good maintainability practices, including comments on why certain design decisions were made. - Handle edge cases and write clear exception handling. - For libraries or external dependencies, mention their usage and purpose in comments. ## Naming Conventions - Follow PascalCase for component names, method names, and public members. - Use camelCase for private fields and local variables. - Prefix interface names with "I" (e.g., IUserService). ## Validation and Error Handling - Guide the implementation of model validation using data annotations and FluentValidation. - Explain the validation pipeline and how to customize validation responses. - Demonstrate a global exception handling strategy using middleware. - Show how to create consistent error responses across the API. - Explain problem details (RFC 9457) implementation for standardized error responses. ## API Versioning and Documentation - Guide users through implementing and explaining API versioning strategies. - Demonstrate Swagger/OpenAPI implementation with proper documentation. - Show how to document endpoints, parameters, responses, and authentication. - Explain versioning in both controller-based and Minimal APIs. - Guide users on creating meaningful API documentation that helps consumers. ## Logging and Monitoring - Guide the implementation of structured logging using Serilog or other providers. - Explain the logging levels and when to use each. - Demonstrate integration with Application Insights for telemetry collection. - Show how to implement custom telemetry and correlation IDs for request tracking. - Explain how to monitor API performance, errors, and usage patterns. ## Testing - Always include test cases for critical paths of the application. - Guide users through creating unit tests. - Do not emit "Act", "Arrange" or "Assert" comments. - Copy existing style in nearby files for test method names and capitalization. - Explain integration testing approaches for API endpoints. - Demonstrate how to mock dependencies for effective testing. - Show how to test authentication and authorization logic. - Explain test-driven development principles as applied to API development.
You can find more samples of instructions in Github page
https://github.com/github/awesome-copilot/tree/main/instructions.
MCP
The real benefits of agents is that they can connect into other systems. Agents can read your email, check your calendar, write code and interact with IDE. GH Copilot CLI supports MCP servers and Claude skills. There is some different between these two in technical details, but you won’t notice them in usage.
MCP servers and skills are capabilities that you give to your agent. You can install MCPs with /mcp add command. MCP servers requires unique name, server type and command/url and list of tools to use. Unique name can be any that you wish. Server type depends on what kind of MCP you are gonna use. Some MCP’s like Microsoft Learn supports using HTTP which is the easiest way to install MCP’s. Others may only support local, which means that you need to install the MCP into your local computer. You can do this by running npm install command. There are multiple MCP registries available in internet that you can use, but https://registry.modelcontextprotocol.io/ is a good place to start.
Skills
Skills are like MCP’s, but they can contain more “information” and context than MCP servers. You can install new skills with /skills add command and view existing with /skills list. I recommend to install anthropic skills by default as it contains good set of some basic skills.
As an example GH Copilot CLI has a pdf skill, which allows Agent to interact with PDF files. If you enter a prompt that requires skills, the GH Copilot CLI shows skill usage with a green dot and skill text.
If you work daily with Jira or Azure DevOps tickets you want to install skill that works for those systems and leverage their capabilities.
Daily Usage
Ok, so what we need to get some use of this tool in our daily usage? For daily usage you need to setup a set of MCP’s and skills first. If you want to use Jira/Confluence, then you need to install the mcp-atlassian with uvx command. Uvx is basically a “package manager” for Python. You can install the mcp-atlassian with command
uvx mcp-atlassian –help.
After installing the MCP, we need to configure it into Github Copilot CLI. The Atlassian MCP requires personal token, that can be generated at Atlassian account | security | api tokens page. I could not get the MCP working with scoped token, so I had to use the API token without scopes.
After creating the token, add mcp-atlassian into GitHub Copilot CLI. You can use GitHub Copilot CLI /mcp add command or directly edit the mcp-config.json file under %userprofile%\.copilot folder.
This is sample config for mcpServer:
"mcp-atlassian": {
"tools": [
"*"
],
"type": "local",
"command": "uvx",
"args": [
"mcp-atlassian"
],
"env": {
"JIRA_URL": "https://(company).atlassian.net",
"JIRA_USERNAME": "(your email linked to atlassian)",
"JIRA_API_TOKEN": "(personal token)",
"CONFLUENCE_URL": "https://(company).atlassian.net/wiki",
"CONFLUENCE_USERNAME": "(your email linked to atlassian)",
"CONFLUENCE_API_TOKEN": "(personal token)"
}
}
Now that we have configured the MCP’s and skills we need, we can start doing some real work. For example if we have confluence page, that contains definitions which we want to convert into Jira tasks. We can ask GitHub Copilot Cli to do that for us. This can be achieved with following prompt.
“Create Jira tickets from confluence page 543452. Split it into one epic that is created from the first chapter and then create user stories based on the confluence page. Link all created tickets under the epic”
You can also use /plan command to build plans that you can manually edit and let copilot implement. For example you can run command“/plan make implementation plan based on confluence page 1230274561” and the GitHub Copilot CLI will create new markdown file with implementation details for you. Then you can edit this markdown and finally ask GH Copilot CLI to implement it.
Pass the Prompts
Github Copilot CLI also supports giving prompts as a parameter and then outputting the result. This is especially good if you want to build commands that you can chain. For example if you need to do a task everytime you do a release, you could create command file (cmd) and describe the task for agent in that command file. This gives you ability to create reusable commands that you can run and even give these actions to your agent.
Summary
GitHub Copilot CLI is a great tool and you should definitely check it out. Is it the AI agent tool that you will use for next 5 years? Not likely. I don’t think these CLI tools are here to stay. They are good for automation, but they are not really good for daily work. Otherwise we wouldn’t have Windows or other graphical UI’s if the CLI tools were here to rule. I think these CLI tools are temporary solution for something bigger that is still cooking. Until that there is no reason to not use them. You will gain performance benefits by using them, so why wouldn’t you?
If you want to learn more about GitHub Copilot CLI, check out their quick start guide: https://docs.github.com/en/copilot/get-started/quickstart