Top 10 GitHub Copilot Commands You Should Know

Welcome to Copilot Friday

What you'll walk away with

Understand

What commands are and why a single / beats re-explaining yourself every time.

Research

Use /research to investigate first and start from facts, not guesses.

Design

Use /impeccable to critique, polish and ship a UI that looks designed.

Prototype

Pair with /rubber-duck to build your own Holiday Itinerary App.

Self-coach

Use /chronicle to spot your own patterns and level up how you work.

Agree

Use /plan to see and approve the work before a single file changes.

Secure

Use /security-review to catch high-confidence vulnerabilities before you commit.

Compact

Use /compact to summarize a long session and keep going without the token cost.

Streamline

Use /caveman to strip the small talk and get short, technical replies.

Duration: 2 minutes

Why commands

What are commands, and why use them?

A command is a saved, expert prompt you trigger by typing /name. Instead of re-explaining what you want every time, you invoke a proven workflow, Copilot already knows the steps, the questions to ask, and what “good” looks like.

/research /impeccable /rubber-duck /chronicle /plan /security-review /compact /caveman

Consistent every time The same command runs the same proven steps — so you get the same quality at 9am or midnight, on your first project or your fiftieth.

Faster than re-explaining One slash beats a paragraph of setup. Skip writing the instructions and jump straight to the work.

Expertise built in Each command carries a specialist workflow — a researcher, a designer, a critic, a coach — so you don't have to be one.

Duration: 5 minutes

Investigate with /research

Before you change a single line, use /research to map the unknowns. It finds the relevant files, separates evidence from assumptions, and hands you a short plan — so every edit starts from facts instead of guesses.

Start from facts, not guesses

Copilot CLI

$/research

# map the problem before you touch code, while changes are still cheap

Without it you jump straight to code

You edit the wrong file first
The real cause surfaces in review
You rework after PR feedback

With it you map the problem first

You change the file that matters
Root cause found before coding
One focused, reviewable patch

Duration: 10 minutes

Design with /impeccable

Once the page works, make it look shipped. /impeccable turns a working prototype into a designed one — it critiques the UX, strips the clutter, audits accessibility, and does a final polish before you ship.

Review the design like a pro

Copilot CLI

$/impeccable critique

# score the itinerary page against UX heuristics

Explore variants, strip the noise

Copilot CLI

$/impeccable live

# pick elements in the browser and generate design alternatives

Ship a designed page, not a draft

Copilot CLI

$/impeccable polish

# final quality pass before the itinerary goes live

Duration: 20 minutes

Pair with a critic using /rubber-duck

Before you build, hand the plan to a second AI model. /rubber-duck reviews Copilot's own plan, code, and tests, flags the blind spots, and hands back concrete fixes — so problems get caught on the plan, not in production.

Catch it before you ship

Copilot CLI

$/rubber-duck

# a second opinion at the plan stage, while fixes are still cheap

Without it one model's judgement

Blind spots reach the live page
You spot the budget error after publishing
Every fix happens in production

With it a second model reviews first

Blocking issues caught on the plan
Edge cases surfaced before you build
You fix it once, not in prod

Duration: 15 minutes

Coach yourself with your own history

Find what you're not using

Copilot CLI

$/chronicle tips

# map recent history to missed CLI and repo capability

Profile the last 30 days

Copilot CLI

$/chronicle cost-tips

# profile 30 days by agent, then drill into cost drivers

Stop the guessing

Copilot CLI

$/chronicle improve

# write your repeated fixes into copilot-instructions.md

Duration: 5 minutes

Agree the build first with /plan

/plan asks the questions a good builder would ask, then shows you exactly what it intends to change — before a single file is touched. You approve the plan, not the surprise.

Approve the approach, not the surprise

Copilot CLI

$/plan

# catch the misunderstanding while it is still free to fix

Without it it builds what it assumed

You find out at the end
Half the page gets rewritten
You describe it all again

With it you agree it up front

You see the steps first
You edit the plan, not the code
One build, not three

Duration: 5 minutes

Catch vulnerabilities with /security-review

/security-review is an experimental command that scans your local code changes and returns high-confidence security findings — scored by severity and confidence — with fixes you can apply without leaving the terminal. It complements code scanning, Dependabot, and secret scanning by catching issues before you even commit.

Fix it in the terminal, not in a PR thread

Copilot CLI

$/security-review

# catch it before review, not after it ships

Without it issues surface later

Found in review, or in production
Scanners run after you push
You re-explain the fix in a PR comment

With it issues surface first

Findings appear before you commit
Severity and confidence guide the fix order
Apply the fix right there in the terminal

Duration: 5 minutes

Free up context with /compact

/compact summarizes the conversation so far into a short recap and keeps working in the same session — instead of re-sending the whole transcript on every turn, Copilot carries the gist forward and drops the dead weight.

Same conversation, fewer tokens on every turn

Copilot CLI

$/compact

# mid-session reset before the transcript gets expensive

Without it every turn re-sends everything

Turn 40 re-sends turns 1 through 39
Input tokens climb, replies slow down
You pay for history you're not using

With it one recap, then a clean slate

One short summary replaces the transcript
Replies stay fast for the rest of the session
Fewer tokens burned per turn, same context

Duration: 5 minutes

Cut the small talk with /caveman

/caveman is a community skill you install once — it swaps Copilot's usual friendly narration for blunt, information-dense replies. Same work, a fraction of the words.

Fewer words, same size project

Copilot CLI

$/caveman

# long sessions cost less per reply, one skill at a time

Without it every reply is a small essay

Friendly narration on every single reply
More tokens spent explaining, fewer on the work
Long sessions get slower to scan

With it replies read like a status line

“Bug in auth middleware. Fix session propagation.”
Denser replies, faster to scan
More budget left for the actual code