Let's Check Out Copilot CLI

Dev Leader Weekly 124

Jan 24, 2026

TL; DR:

I like it even as an IDE user!
Powerful and integrates with Github ecosystem
Check out the live stream on Monday, January 26th at 7:00 PM Pacific!

GitHub Copilot CLI’s New Power Moves

If you spend time in the terminal, you know the sweet feeling of getting into flow and staying in flow. The latest GitHub Copilot CLI updates are built to let us do exactly that. Copilot CLI is essentially your AI pair programmer, right there in bash or Powershell. It “brings AI-powered coding assistance directly to your command line”, meaning it can not only write code but execute shell commands (with your permission) as part of its work. Think of it like chatting with a teammate named “Copilot” who never gets tired, works in the dark, and doesn’t mind repeating themselves.

Ever since Copilot CLI launched in public preview, the team has been on a tear adding features to make it more useful and predictable. The January 2026 changelog sums it up nicely: Copilot CLI “continues to push the boundaries of agentic AI assistance in your terminal”. We’ve now got powerful new reasoning models, built-in planning tools, better context management, and even first-class GitHub CLI integration. These features can seriously upgrade your dev workflow. Let’s walk through what’s new, why it matters, and how you can make Copilot CLI work for you.

If you’re curious beyond the article, I have been starting to create videos around my usage with Copilot CLI, starting off with some basics on model selection:

Plan Mode: Map It Out Before You Code

One of the biggest headliners is Plan mode. The idea of “team-first development” applies here -- this is Copilot’s way of joining the planning meeting before the coding starts. Instead of rushing into code, you can use the /plan command (or press Shift+Tab to toggle between plan and normal mode) and Copilot switches into a conversational planning flow. It asks clarifying questions about scope and requirements, and then sketches out a structured implementation plan before writing a single line of code.

In practice, it’s like talking through the feature with a peer. Try it on a side project: say “build a simple todo API” and use /plan. Copilot will ask if you want REST endpoints or GraphQL, what kind of database, and how to handle edge cases. Give it a few details, and it generates a step-by-step plan you can review. Having this plan up front changes your perspective. It catches misunderstandings (you might realize you hadn’t specified a user auth requirement!), and gives you confidence in the approach before any code is written.

This kind of approach isn’t unique to the Copilot CLI, of course. Many of you have seen this with Claude Code, and I’ve even talked about planning discussions in GitHub spaces:

A quick tip: use /clear to reset the session if context gets messy, and /cwd to make sure Copilot is working in the right directory. Once plan mode is done, review the outline, then tell Copilot to run (by toggling out of plan mode with Shift+Tab) and watch it implement step by step. It’s a new way to work iteratively -- think, “plan, code, adjust, plan again,” rather than code blind. This fits a typical engineering workflow: first architect, then implement. Copilot CLI even remembers past plans to some extent (more on memory below), so your “plans for features” can become part of your project’s evolving documentation.

Slash Commands: Keyboard Shortcuts for AI

Working in the terminal is all about efficiency, and Copilot CLI’s slash commands are magic for that. These are literally commands that start with /, like /clear, /model, or /add-dir, and they trigger Copilot to perform a specific task. Instead of guessing the right natural language prompt, you just issue a command. As the docs say, slash commands give us “quick, explicit, and repeatable commands directly in your workflow”. A few of them quickly become muscle memory.

For example, start a fresh CLI session with /clear to wipe any old context. When switching projects, hit /cwd <path> to tell Copilot “now focus on this folder,” and it replies “Changed working directory to: …”. For a specific model or detail level, use /model gpt-5.2-codex to pick the latest code-specialized model (GPT-5.2-Codex is now available) or use --model. The command /help or just / will list everything available. These shortcuts make Copilot’s actions predictable and fast, which is huge. No more copy-pasting long prompts; there’s a command for common tasks like fixing linter errors, running tests, or even viewing session usage.

Copilot’s blog has a great slash-command cheat sheet. They highlight that /clear, /cwd, and /model cover your bases: clear the slate, set the directory, pick the intelligence level. Also worth knowing: /add-dir and /list-dirs to control file access (important in a team or security context), and /review for quick code reviews (more on that in a bit!). The nice part is that slash commands fit into any workflow: you type them while in a Copilot CLI chat, or even in a GitHub Copilot chat session elsewhere. They are explicit shortcuts, so every team knows exactly what’s happening (no magic voodoo prompt interpretation).

Pro tip -- slash shortcuts to remember: use /clear when Copilot is repeating old context, /cwd to switch projects, and /model if you want the highest quality output (or experiment with GPT-5.2’s “extra reasoning” level). And don’t forget /delegate to hand off complex tasks to Copilot’s cloud-based coding agent.

Steering and Iterating: Stay in Control

One big theme here is iterative, steerable workflows. Copilot CLI was already conversational, but now you can even chat with it during its thinking. Say Copilot is in the middle of generating code; you can type follow-up instructions on the fly, which enqueues them for after its current response. This is so handy. The conversation feels natural -- you don’t have to wait, type a new prompt, and wait again. You can correct course midstream. For example, say Copilot is writing a feature and you realize you need to tweak something: instead of restarting, just type an instruction like “Actually, use a priority queue here,” and it queues it up seamlessly.

To be honest, I am VERY much a die-hard Visual Studio user because I really prefer working in an IDE compared to a command line. But this ability to naturally interrupt and redirect the agent in chat makes the CLI experience really smooth. I’m hopeful we’ll see more of this migrate to Visual Studio as well.

If Copilot asks permission to run a tool (like npm install or git), you can now give quick inline feedback. If you reject an action, Copilot will ask why or adapt, rather than just stopping dead. It’s like telling your pair-programmer, “Hey, that’s a sensitive directory, try another way,” and the AI remembers for the rest of the session. The goal is keeping you in charge.

Another powerful feature is cloud delegation with /delegate. This command pushes your current session to Copilot coding agent on GitHub. When you run /delegate complete the API integration tests, Copilot will commit any unstaged changes as a checkpoint, create a new branch, and open a draft pull request. The coding agent then works in the background on GitHub’s infrastructure, and you’ll get a link to the PR and agent session. You can continue working locally while Copilot handles the delegated task in the cloud. I’m personally not at the point where this context switch is natural, but I do love delegating work to cloud agents in general so that I can focus on whatever else I am building.

All these features aim to make the workflow feel like coding with a live teammate, where you can pause, redirect, and multitask. No more waiting idly for long outputs or losing your train of thought while Copilot scribbles away.

Keeping Context Sharp: /compact and /context

Working iteratively means building up a conversation. But we all hit token limits eventually. Copilot CLI now handles that gracefully. It will auto-compress (auto-summarize) your chat history in the background when you hit about 95% of the token limit. You might not even notice it happening, except that your session can keep going “virtually infinite.” If you want control, use the /compact command anytime to manually force a trim. Press Esc to cancel if you change your mind.

And if you’re ever curious how much brain space Copilot is using, /context will give a token breakdown. This is especially useful when juggling multiple tasks in one session. Keeping context tight means the AI stays focused, which is crucial for accurate responses. In fact, Claude Code (Anthropic’s tool) also does auto-compaction when it gets full, so these agents are thinking about the same problems of context drift. The lesson for us is to periodically clear or compact context, especially when switching tasks -- otherwise AI suggestions can start referencing outdated stuff.

Enhanced Permissions: Trust But Verify

Teams working in sensitive codebases will appreciate the finer permissions controls. Now, when Copilot asks for tool approval, you can select “Yes, and approve TOOL for the rest of the running session” to automatically approve similar requests. For instance, if you let it run one npm install, it won’t bug you again for every package in that session. And if you do trust Copilot completely, there are flags like --allow-all (which enables auto-approval of all tools and paths) or the /yolo command to enable YOLO mode -- letting Copilot run freely without prompts. Use these carefully, but they can save clicks when you’re in a trusted environment (or just tinkering locally).

For me? Once I saw Copilot trying to push changes to my remote repository, I made a promise to myself that I wouldn’t touch YOLO mode. I feel quite confident with the file changes and such locally, but once it starts to try and push code on its own I get very concerned!

All of this makes Copilot’s actions more transparent and team-friendly. You’re building an audit trail. Slash commands like /add-dir, /list-dirs, and /usage ensure everything Copilot does is explicit. In a real-world team, that means there are no surprises about where your AI “coworker” is poking around.

Instant Code Reviews: The /review Command

A huge time-saver: the new /review command. Instead of jumping into GitHub.com or a separate tool, you can ask Copilot right in the terminal to review your latest changes. Just stage your code, run /review, and Copilot analyzes the diff. It will point out things like potential bugs, security issues, or anything odd it sees. It’s a “quick sanity check” without leaving your editor.

In practice, run this before you commit or open a PR. It’s like having a second set of eyes on your code. For example, /review might flag a missed null-check or a missing await in an async function -- issues you can fix before even pushing. This kind of on-the-fly review keeps quality high and saves rounds of back-and-forth later. If you’re on a team with coding standards, you can even feed Copilot a style doc via custom instructions (see next) so the feedback aligns with your conventions.

Custom Instructions: Teaching Copilot Your Project’s Rules

One of the most exciting under-the-hood updates is custom instructions support. Copilot CLI can read instruction files from your repository that persist across sessions. Think of it as teaching the AI your project’s personality. You define coding standards, architecture patterns, even how your team likes naming things, and Copilot references these instructions automatically.

Why does this matter? Because it means you don’t have to re-explain your project setup every session. Copilot will already know, “Oh right, we always put logging in this helper class,” or “We favor snake_case in our database fields.”

Copilot CLI supports these instruction file locations:

Repository-wide instructions: .github/copilot-instructions.md
Path-specific instructions: .github/instructions/**/*.instructions.md
Agent files: AGENTS.md (in git root and cwd)
User-level instructions: $HOME/.copilot/copilot-instructions.md

Note: If you’ve used Claude Code (Anthropic’s CLI tool), you may be familiar with CLAUDE.md files. Copilot CLI can also read CLAUDE.md and GEMINI.md files for compatibility, but its native instruction format is .github/copilot-instructions.md. If you’re setting up instructions specifically for Copilot, use the .github/ path.

You can think of it like having a persistent conversation with the AI about your codebase. An easy way to use this is by creating a .github/copilot-instructions.md file in your repo that outlines the big rules of your project. Copilot will pick that up and adjust its answers. For example, if you save your API conventions in the instructions file specifying that you use Express, Copilot will stop suggesting incompatible frameworks like Sinatra.

Bottom line: invest a little effort in “teaching” Copilot once, and it pays dividends forever. Beyond that? I’ve made videos talking about how I use Roslyn analyzers to further steer Copilot:

GitHub CLI Integration: “gh copilot”

Another nice productivity bump: you can now install and run Copilot CLI through the GitHub CLI. Just run gh copilot in your terminal. The first time it will prompt you to install Copilot CLI, and after that gh copilot launches it. This is clutch for people who already use gh for their workflow. You can add it to a quickstart script so new teammates get Copilot CLI set up automatically.

Bonus: GitHub Actions will auto-install Copilot CLI too. So if you want to embed Copilot CLI tasks in a CI/CD pipeline, it’ll just come up without manual steps. In short, gh copilot turns Copilot CLI into a first-class citizen of the GitHub tool ecosystem. Don’t overlook this: using gh copilot means you don’t have to juggle Homebrew or npm installs on every machine.

Looking Around: Claude Code and Other AI CLI Tools

You might wonder how this stacks up with other AI coding CLI tools like Anthropic’s Claude Code. In concept, they share some ideas: Claude Code also has a plan-mode (activated by Shift+Tab) and slash commands, so you can create a file of tasks and iterate through them. One blogger demonstrated a workflow with custom slash commands to manage a checklist-style development flow. For a deeper dive into Claude Code’s features, check out this guide to slash commands, agents, and skills.

But Copilot CLI ties tightly into GitHub. For example, Copilot’s /delegate can push tasks to GitHub’s cloud-based coding agent, and /review plugs directly into your Git diffs. Claude Code, on the other hand, uses CLAUDE.md context files and its own agents. Both have context compaction and memory features. For a side-by-side comparison of these tools, check out jgandrews’ writeup. The key takeaway is that whether you use Copilot CLI or Claude Code, the pattern is similar: break your work into steps, keep the context clear, and iterate. If your team uses GitHub everywhere, Copilot CLI is a natural choice -- but it’s worth knowing other tools exist.

(And for the record: yes, in Claude Code you can even route it to call GitHub Copilot CLI via shell if you really want to mix and match, which is a fun experiment but gets advanced quickly.)

Actionable Tips for Your Workflow

Let’s translate all this into things you can do right now:

Install Copilot CLI: If you have GitHub CLI (gh) installed, just run gh copilot. It will handle the install or prompt you. Otherwise follow the docs. Make sure you’re on Copilot Pro/Enterprise if it asks for licensing.
Explore /help: Open a Copilot CLI session, type / or /help, and get familiar with commands. Try /clear, /cwd, /list-dirs, /review. The cheat sheet on the GitHub blog is a great reference.
Try Plan Mode: Pick a small feature you want to build (even “Write a function to...”). Use /plan or press Shift+Tab in the CLI to enter plan mode. See what questions Copilot asks. Answer them. When you’re done, review the plan and toggle back to normal mode. Watch how Copilot turns plan into code.
Use Cloud Delegation: For a longer task (like scaffolding a module or complex refactor), try /delegate your task description here. Copilot will create a branch and PR, then work in the background on GitHub while you continue locally.
Commit Reviews: Before your next commit, stage your changes and run /review. Take Copilot’s feedback seriously. It might catch security issues, missing docs, or suggest improvements.
Set Custom Instructions: Create a .github/copilot-instructions.md file describing your project’s tech stack, conventions, and goals. Copilot CLI will use that as context. This is like having a consistent onboarding for the AI.
Monitor Usage: If you’re on a plan with usage limits (e.g. Copilot Pro has a token budget), use /usage and /session to see what you’ve spent during your session. It helps avoid surprises on your bill.
Join the Community: The Copilot CLI repo on GitHub is public. If something doesn’t work, check the issues there. Since it’s still in public preview, the team is actively listening. Also, share your tips with your teammates -- these features are still new to many of us.

Keep Coding, Together

Copilot CLI’s updates are not just shiny new toys; they’re designed to fit how we actually build software. Planning, clear commands, context-awareness, and the ability to course-correct mirror a good team workflow. Using these features feels like having a dedicated helper who’s learning your codebase and following directions -- fast and tireless, but definitely still on your team.

Experiment with these tools, but stay in the loop. AI isn’t here to replace the dev on the team, it’s here to eliminate grunt work. Keep reviewing what Copilot does (after all, you know the project best), and feed your insights back to it (literally through instruction files). If it makes you more productive and your code more polished, it’s earned its place in the toolkit.

Ready to dive in? Open up your terminal, update Copilot CLI, and start chatting. Ask it to draft a plan, run tests, fix bugs, or explain code -- all without leaving your shell. At the end of the day, these new Copilot CLI features mean one thing: more time writing good code and less time context-switching between windows.

Dev Leader Weekly

Discussion about this post

Ready for more?