Prompt Academy 37 min read Last updated October 17, 2026 25 sources

AI Commands Dictionary

A two-part dictionary: prompt command words (summarize, critique, steelman, answer only from the text and more) with examples and pitfalls, and the slash commands that really exist in major AI tools, checked against official documentation.

On this page

How the dictionary is organised
Alphabetical index (Part A)
Part A: Prompt command words
Transform text
Analyze and judge
Create and plan
Reasoning and explanation
Role, voice and perspective
Constraints and control
Conversation controls
Try these prompts: transform and rewrite commands
Try these prompts: analyze, judge and extract commands
Try these prompts: create and plan commands
Try these prompts: reasoning, role and control commands
Notes on a few commands
Part B: Slash commands and built-in commands in major AI products
Product coverage summary
Claude Code (Anthropic)
ChatGPT desktop app composer (OpenAI)
Gemini CLI (Google)
GitHub Copilot Chat (GitHub)
GitHub Copilot CLI (GitHub)
Microsoft 365 Copilot Chat (Microsoft)
Gemini app (Google)
Claude (web and apps), Perplexity, Grok
Common mistakes
Checklist
Glossary
Sources

Filter this dictionary

TL;DR
Part A explains 87 everyday prompt command words (not software commands): what each asks the model to do, a short example, and the usual pitfall. They work in any chat tool.
Part B lists slash and built-in commands that appear in official documentation for Claude Code, the ChatGPT desktop app composer, Gemini CLI, GitHub Copilot (chat and CLI) and Microsoft 365 Copilot Chat. Anything I could not confirm in an official source is excluded or tagged [VERIFY].
Not every chat app has slash commands. For several well-known products (ChatGPT on the web, Claude on the web, Perplexity, Grok) I could not find an official command list, so none is given. Use the app's own / menu or help page.
Command lists change often. Everything in Part B is "as of 2026-10-17". Type / in your tool to see what your version supports.
How to use this page: use the alphabetical index to jump to a Part A entry; use your browser's find (Ctrl or Cmd + F) or a table filter to search either part.

How the dictionary is organised #

Consistent tables. Part A tables have four columns: Command | What it does | Example | Pitfall. Part B tables have three: Command | What it does | Notes.
Citations. Bracketed numbers like [15] point to the Sources list at the end.
Honesty about scope. Part A words are conventions that work because models understand natural language; they are not official keywords of any product, and results vary by model. Part B items are real product commands that I checked in the vendor's documentation on 2026-10-17.
Prompts in the library. "Try these prompts" lists existing prompt ids from our library for each group.

Alphabetical index (Part A) #

A: Act as · Analyze · Answer only from the text · Ask me questions first · Audit B: Brainstorm · Break down C: Change tone · Checklist · Cite sources · Classify · Compare · Condense · Continue · Contrast · Convert · Critic and reviser · Critique D: Design · Devil's advocate · Diagnose · Do not invent · Do not use · Draft E: Edit · Estimate · Evaluate · Expand · Explain · Explain like I'm 12 (ELI12) · Explain like I'm 5 (ELI5) · Extract F: Fact-check · Find gaps · For this audience · Format G: Generate · Give 3 options I: Identify risks J: Justify K: Keep my voice L: Limit to N words · List your assumptions · Localize O: Outline · Output as a table · Output as JSON · Output as Markdown P: Paraphrase · Plan · Prioritize · Proofread · Pros and cons Q: Quote your source R: Rank · Red-team · Redact · Remember / save as default · Repeat the key instruction · Review · Rewrite · Roadmap · Role-play S: Say 'I don't know' · Score · Script · Shorter / longer · Show your work · Simplify · Socratic mode · Start over · Steelman · Step order · Storyboard · Summarize · Summarize the chat so far T: Tag · Template · Think step by step · Translate · Try again U: Use a template · Use plain language V: Verify W: Walk me through · Write · Write as / in the voice of

Part A: Prompt command words #

These are phrases you put in a prompt. A good command word is rarely enough on its own; pair it with an audience, a format, a limit and a source. Researchers have catalogued dozens of named prompting techniques [20], but for everyday use the useful split is by what you want done. Vendors' guides all stress being specific about the task, format and constraints [9][12][15][16], and the Microsoft Copilot guidance says only a clear goal is required, with context, source and expectations improving the result [24].

Transform text #

Command	What it does	Example	Pitfall
Summarize	Shrink text to its main points.	`Summarize the email thread below in 5 bullets for a manager; put decisions first.`	No audience or length gives a generic summary; the model may drop numbers or add claims. Ask it to keep figures exactly.
Condense	Shorten while keeping the meaning and structure.	`Condense this paragraph to 40 words without losing the date and the price.`	May change nuance; compare against the original.
Rewrite	Say the same thing in different words or a different form.	`Rewrite this notice for parents, plain language, keep all dates.`	Without constraints it may add or drop facts; add 'do not add new facts'.
Paraphrase	Re-express a passage in your own wording at similar length.	`Paraphrase this explanation so a student can read it aloud.`	Not a substitute for citing the source; check meaning is intact.
Simplify	Lower the reading level and jargon.	`Simplify this clause for a reader with no legal training; keep it under 80 words.`	Simplifying can distort legal or medical meaning; have an expert check anything important.
Expand	Add detail, examples or length to a short draft.	`Expand these three bullets into a 200-word update; use only facts I gave.`	Invites invented detail; say what sources it may use.
Proofread	Fix spelling, grammar and punctuation without changing content.	`Proofread the text; list each change in a table (original, corrected, reason).`	May 'improve' style too; say 'do not change wording beyond errors'.
Edit	Improve clarity and flow with light changes.	`Edit for clarity; cut about 15 percent; keep my voice; mark every change.`	Unclear scope; define whether you want line edits or restructuring.
Change tone	Shift the register (formal, warm, firm) while keeping facts.	`Rewrite in a firm but polite tone; do not threaten or add demands.`	Tone words are vague; give an example sentence you like.
Format	Reshape content into a layout such as a table, list or email.	`Format these notes as a two-column table: action, owner.`	May reorder or lose items; ask it to confirm the item count.
Translate	Convert text between languages.	`Translate to Spanish for Mexican readers; keep names unchanged; list any phrase you were unsure of.`	Idioms, legal terms and regional forms can be wrong; have a fluent reader check important text.
Localize	Adapt content for a region, not just the language.	`Localize this offer for UK readers: spelling, units, dates and currency.`	Can miss cultural or legal differences; name the country.
Convert	Change data or text from one form to another (units, format).	`Convert these dates to YYYY-MM-DD and list any you could not parse.`	Silent mistakes with ambiguous values; ask for a list of anything uncertain.
Redact	Remove or mask sensitive details.	`Replace names, emails and account numbers with [REDACTED-TYPE]; list what you replaced.`	Models can miss items; check manually before sharing, and avoid pasting real secrets in the first place.

Analyze and judge #

Command	What it does	Example	Pitfall
Compare	Set items side by side on stated criteria.	`Compare options A and B on cost, risk and effort in a table; say which criteria are missing data.`	Unequal depth between options; give criteria and weights.
Contrast	Focus on differences only.	`Contrast the two policies; list only the differences, each with the clause number.`	Missing subtle differences; ask for 'every difference, even small'.
Critique	Point out weaknesses and how to fix them.	`Critique this draft against this rubric; list the 3 biggest problems and a fix for each.`	Flattering or vague feedback; require specific lines and a rating.
Review	Check a document against criteria and report findings.	`Review this contract against my checklist; quote the clause for each finding.`	May miss issues; it is a first pass, not a final check.
Audit	Systematically check against a standard and list gaps.	`Audit this page for readability: list issues by severity with a line reference.`	Needs a standard; otherwise it invents one.
Evaluate	Judge quality or fit against criteria, with a score.	`Evaluate each answer 1 to 5 on accuracy and clarity with a one-line reason.`	Scores drift between runs; fix the rubric and test on examples [22][23].
Analyze	Examine to find patterns, causes or implications.	`Analyze these survey comments; group into themes with counts and 2 quotes each.`	Too broad without a question; say what decision it supports.
Diagnose	Find the likely cause of a problem.	`Diagnose why this spreadsheet formula returns #N/A; list 3 likely causes in order.`	Presents guesses as facts; ask for how to test each cause.
Extract	Pull specific items from text into a fixed structure.	`Extract vendor, date, total and currency as JSON; use null when missing.`	Invented values when text is silent; require 'null if absent' and quote the source line.
Classify	Assign items to categories.	`Classify each message as BILLING, BUG or OTHER; reply with the label only.`	Unclear edge cases; supply 2-3 examples and an 'unsure' label [15].
Tag	Attach labels or keywords to items.	`Tag each article with up to 3 topics from this list only.`	Drifts outside your list; say 'only from this list'.
Rank	Order items from best to worst on stated criteria.	`Rank these 6 ideas by impact and effort; show the scores and reasons.`	Rank without criteria is arbitrary; ask for the scoring table.
Prioritize	Decide what to do first.	`Prioritize these tasks using impact and urgency; flag dependencies.`	Ignores your constraints unless stated (time, budget).
Score	Give numeric ratings against a rubric.	`Score this reply 1-5 on tone, accuracy and completeness; justify each.`	Inconsistent scale; define what each number means.
Fact-check	Verify claims against sources.	`List each factual claim in the text, then say supported, contradicted or not in the sources provided.`	A model without sources can only guess; provide the sources or a search tool, and verify key facts yourself [11].
Find gaps	Identify what is missing.	`List what is missing from this plan that a reviewer would ask about.`	Generic gaps; give the audience and purpose.
Estimate	Give an approximate quantity with assumptions.	`Estimate weekly hours for this task; state assumptions and a range.`	False precision; ask for low, likely, high.
Identify risks	List things that could go wrong.	`Identify the top 5 risks to this launch with likelihood, impact and a mitigation.`	Boilerplate lists; give context and constraints.

Create and plan #

Command	What it does	Example	Pitfall
Outline	Produce a structure of headings and key points.	`Outline a 10-minute talk for school governors on data privacy; 5 sections with one line each.`	Too generic; give audience, length and goal.
Draft	Write a first version for you to edit.	`Draft a 120-word notice from these facts; mark anything you assumed.`	Treat as a draft; check facts and tone.
Write	Create new text from a brief.	`Write a two-paragraph product description; friendly tone; under 100 words.`	Needs facts supplied, or it fills gaps with plausible guesses.
Generate	Produce multiple options or items.	`Generate 8 subject lines under 50 characters; mix curiosity and clarity.`	Near-duplicates; ask for variety and a reason for each.
Brainstorm	Produce a wide range of ideas.	`Brainstorm 15 ideas for a staff wellbeing week; include 3 that cost nothing.`	Safe, similar ideas; require a range and constraints.
Plan	Break a goal into ordered steps with dates or owners.	`Plan a 4-week rollout with weekly goals, owners and risks.`	Unrealistic timing; give your real capacity and deadlines.
Roadmap	Lay out phases and milestones.	`Draft a 3-phase roadmap for a mobile app launch; list dependencies.`	Scope creep; state what is out of scope.
Design	Propose a structure or solution to a design problem.	`Design a folder structure for a 5-person agency; explain trade-offs.`	Over-engineering; state constraints and size.
Template	Create a reusable fill-in-the-blank version.	`Turn this email into a template with [PLACEHOLDERS] and a list of the fields.`	Placeholders may hide required context; list inputs.
Checklist	Turn a process into tick-box steps.	`Make a pre-launch checklist from these notes; group by owner.`	Missing steps you did not mention; ask it to flag assumptions.
Script	Write words to be spoken or a dialogue.	`Write a 60-second phone script for confirming an appointment; polite; one clear ask.`	Sounds stiff; read aloud and edit.
Storyboard	Plan visuals or scenes in order.	`Storyboard a 45-second explainer in 6 frames: visual, caption, timing.`	Detail without brand guidance; supply style notes.

Reasoning and explanation #

Command	What it does	Example	Pitfall
Explain	Describe how or why something works.	`Explain how compound interest works with one numeric example.`	Confident errors; ask for the assumptions and verify with a reliable source.
Explain like I'm 12 (ELI12)	Explain at a young teenager's level.	`Explain inflation like I'm 12; use a lemonade stand example; 100 words.`	Oversimplifies; follow with 'what did you leave out?'.
Explain like I'm 5 (ELI5)	Explain with very simple words and analogies.	`ELI5: how does a vaccine train the body? Under 80 words.`	Analogies can mislead; do not use for safety-critical advice.
Think step by step	Ask for intermediate reasoning before the answer.	`Work through this in numbered steps, then give the final answer on its own line.`	Helps multi-step problems on standard models [17][18]; with reasoning models, vendors advise against it [13]; reasoning text can still be wrong.
Show your work	Display calculations or evidence.	`Show the arithmetic in a table, then the result.`	Looks convincing even when wrong; recompute key numbers.
List your assumptions	State what is taken as given.	`Before answering, list assumptions you are making and mark which need checking.`	Assumptions may be unstated unless asked; request them first.
Break down	Split a task into smaller parts.	`Break this project into milestones of under 1 week each.`	Parts may be uneven; ask for dependencies.
Pros and cons	List benefits and drawbacks.	`Give pros and cons of renting vs buying; include what would change the answer.`	Even-handed by default, which can hide a clear answer; ask for a recommendation with reasons.
Walk me through	Guide step by step interactively.	`Walk me through setting up a shared calendar, one step at a time; wait for my reply.`	May dump everything at once; say 'one step, then wait'.
Justify	Give reasons or evidence for an answer.	`Give your recommendation and justify it with two pieces of evidence from the text.`	Fabricated justification; require quotes from provided text.

Role, voice and perspective #

Command	What it does	Example	Pitfall
Act as	Adopt a role or point of view for the answer.	`Act as a sceptical finance director reviewing this budget; list 5 questions you would ask.`	Role names alone add little; give the audience, goal and constraints [10]. Do not treat the role as real expertise.
Write as / in the voice of	Match a style from supplied samples.	`Write in the style of the three samples below; do not copy phrases.`	Imitation of a named living author raises style and copyright concerns; use your own samples.
For this audience	Tailor to a reader's knowledge and needs.	`Explain to a busy nurse manager with no data background; 150 words.`	Stereotyping; describe knowledge and needs, not demographics.
Role-play	Practise a conversation with the model in a role.	`Role-play a difficult customer; I reply; give feedback after 5 turns.`	Realism varies; set rules and an end point.
Steelman	Present the strongest fair version of a view you may disagree with.	`Steelman the argument for a four-day week; strongest points first; cite no invented data.`	Can sound persuasive about weak claims; ask for the evidence needed to hold the view [21].
Devil's advocate	Argue the opposite to test an idea.	`Play devil's advocate against this plan; 5 strongest objections.`	May exaggerate; ask for ranking by likelihood.
Red-team	Try to find how a plan, prompt or system could fail (defensively).	`Red-team my customer-support prompt: list inputs likely to make it misbehave, and fixes.`	Use only on your own systems; do not ask for attack instructions.
Critic and reviser	Alternate critique and revision rounds.	`Draft, list 3 flaws, then revise; show only the final version and a change list.`	Endless polishing; set a round limit [19].
Socratic mode	Teach by asking questions.	`Teach me recursion with questions only; wait for my answers.`	Frustrating if you want a quick answer; set a limit.

Constraints and control #

Command	What it does	Example	Pitfall
Answer only from the text	Restrict the answer to supplied material.	`Use only the text in <policy>. If it does not say, answer 'The policy does not say'.`	Does not fix a wrong source; ask for quotes [11][15].
Do not invent	Forbid made-up facts or sources.	`If you do not know, say so; do not guess names, numbers or links.`	Not a guarantee; verify [11].
Quote your source	Show the supporting passage.	`After each claim give the exact sentence you used in quotation marks.`	Quotes can be wrong; check against the original.
Cite sources	Attach references.	`Cite the document name and section for each point.`	Models may invent citations if no sources are given [11].
Say 'I don't know'	Give the model an honest exit.	`If the answer is not in the file, reply 'Not found' instead of guessing.`	Needs to be specific about when to use it [11][15].
Ask me questions first	Interview-first: collect missing information.	`Before drafting, ask me up to 5 questions, one at a time.`	May ask too many; set a number.
Give 3 options	Return a small set of alternatives to choose from.	`Give 3 options, each with a one-line trade-off; recommend one.`	Options may be near-identical; require different approaches.
Output as a table	Request tabular output.	`Return a table with columns: item, owner, deadline, status.`	Wide tables break in narrow views; fix column count.
Output as JSON	Request machine-readable output.	`Return only valid JSON with keys: vendor, date, total.`	Extra prose or wrong keys; use schema features where available [14].
Output as Markdown	Request headings, lists and emphasis.	`Use H2 headings and short bullets.`	Rendering differs between apps.
Limit to N words	Set a length cap.	`No more than 120 words.`	Models approximate counts; check.
Use a template	Fill a given structure exactly.	`Fill this template exactly; keep headings unchanged.`	Skips sections you consider optional; say 'all sections'.
Use plain language	Avoid jargon.	`Plain language, sentences under 20 words.`	Oversimplification; keep key terms defined.
Do not use	Ban words, topics or formats.	`Do not use the words 'leverage' or 'synergy'; no exclamation marks.`	Negatives work less well alone; add the positive version [10].
Keep my voice	Preserve your style while editing.	`Edit but keep my phrasing wherever it is clear.`	Gradual drift; compare to the original.
Step order	Make steps sequential and complete.	`Number the steps; do not skip any.`	Missing hidden steps; ask for prerequisites.
Verify	Ask the model to check its own answer against criteria.	`Check your answer against the source and list anything unsupported.`	Self-checks miss errors; independent checking is better.
Repeat the key instruction	Restate the main rule at the end of a long prompt.	`Reminder: answer in under 100 words and cite page numbers.`	Clutter; use for long inputs only [15].

Conversation controls #

Command	What it does	Example	Pitfall
Continue	Pick up where output stopped.	`Continue from the last sentence.`	May repeat or drift; give the last line.
Try again	Redo with a change.	`Try again with a more formal tone and one example.`	Without a change you often get the same result.
Shorter / longer	Adjust length.	`Shorter: halve it; keep the first and last points.`	Loses detail; say what to keep.
Start over	Reset and restate the task.	`Ignore the above. New task: ...`	Old context may still influence; use a new chat for unrelated tasks.
Summarize the chat so far	Create a handover for a fresh chat.	`Summarize decisions and open questions so I can paste them into a new chat.`	May omit details; check before using.
Remember / save as default	Ask the app to remember a preference (if the product has memory).	`Remember that I prefer British spelling.`	Depends on the product's memory settings and privacy rules [VERIFY].

Try these prompts: transform and rewrite commands #

create-ai-prompt-patterns-by-task-0001: Plain-Language Rewrite With a Banned-Phrase List
create-ai-prompt-patterns-by-task-0003: TL;DR Summary With Key Decisions and Open Questions
create-ai-prompt-patterns-by-task-0004: Turn Rough Notes Into a Clean Draft Without Adding Facts
create-ai-prompt-patterns-by-task-0005: Jargonize and De-Jargonize Pair
create-ai-prompt-writing-0009: Summarization Prompt With Audience and Length Control
create-ai-prompt-writing-0011: Rewrite in a Target Voice With Examples Prompt
create-business-document-practice-0004: Word Proofreading Pass With a Change Log That Protects Meaning
create-creative-editing-and-feedback-0006: Proofreading Pass Checklist
audit-content-writing-quality-0003: Readability and Plain Language Audit
audit-content-writing-quality-0018: Tone Calibration for Different Audiences
create-customer-quality-training-0004: Tone and Empathy Rewriting Exercises
audit-content-brand-voice-0016: Translation and Localization Voice Review

Try these prompts: analyze, judge and extract commands #

create-ai-prompt-writing-0010: Information Extraction From Messy Text Prompt
create-ai-prompt-writing-0013: Analysis Prompt That Requires Evidence
create-ai-prompt-writing-0004: Few-Shot Example Designer for a Classification Task
create-ai-prompt-patterns-by-task-0012: Critique My Draft Without Flattery
create-product-roadmaps-and-priorities-0002: RICE Prioritization Worksheet
create-spreadsheets-formulas-functions-0025: Weighted Scoring Matrix for Decisions
audit-legal-contracts-0001: Contract Plain-Language Risk Summary
create-product-discovery-research-0005: Competitor Analysis for Product Decisions
audit-content-writing-quality-0005: Executive Summary Quality Review
create-business-business-plans-0035: Business Plan Red Team Review

Try these prompts: create and plan commands #

create-ai-prompt-writing-0012: Brainstorming Prompt With Constraints
create-public-talk-outlines-0002: Conference Keynote Outline From One Idea
create-podcast-episode-planning-0003: Episode Outline Builder With Timings
create-product-roadmaps-and-priorities-0001: Outcome-Based Roadmap Draft
create-ai-prompt-writing-0001: Vague Request to Strong Prompt Rewrite
create-ai-prompt-writing-0003: Role Context Task Format Prompt Builder
create-ai-workflow-design-0001: Map a Repetitive Task Into an Automation Spec
create-ai-prompt-writing-0014: Code Generation Prompt With Tests

Try these prompts: reasoning, role and control commands #

create-ai-prompt-patterns-by-task-0007: Step-by-Step Reasoning Request With Visible Checks
create-ai-prompt-patterns-by-task-0002: ELI5 Explainer With a Check Question
create-ai-prompt-patterns-by-task-0009: Role-Play a Difficult Stakeholder for Practice
create-ai-prompt-writing-0005: Prompt Chain Planner for Complex Tasks
create-ai-prompt-writing-0002: Make the AI Ask Questions First
create-ai-prompt-writing-0006: Output Format Specification Writer
create-ai-prompt-writing-0016: Prompts That Cite Sources and Admit Uncertainty
create-ai-prompt-writing-0017: Negative Instructions to Positive Instructions Rewrite
create-ai-custom-instructions-assistants-0005: Socratic Tutor Assistant Instructions
create-ai-evaluation-testing-0013: Defensive Red-Team Checklist for a Customer Support Agent
create-ai-prompt-testing-improvement-0016: Skeptical Colleague Prompt Review Role-Play
create-ai-prompt-testing-improvement-0007: Hallucination Reduction Checklist for a Prompt

Notes on a few commands #

"Think step by step." Research found that asking for reasoning steps, with or without worked examples, improved results on arithmetic and logic benchmarks for large models [17][18]. Current vendor documentation is more nuanced: OpenAI advises not asking reasoning models for step-by-step explanations because they reason internally [13], and Microsoft says its step-by-step techniques are not recommended for reasoning models [15]. Use it for standard chat models and multi-step problems, and use "list your assumptions and checks" when you only need an audit trail.

"Act as." Setting a role can shape tone and focus, but Anthropic's current guidance says heavy role prompting is less necessary than it once was; clarity about the task and audience matters more [10].

"Answer only from the text." This is grounding. Microsoft calls it among the most effective ways to improve reliability, and recommends giving the model an "out" such as "not found" [15]. Anthropic recommends quote-first extraction for long documents and allowing "I don't know" [11].

"Output as JSON." Asking in words may give invalid or extra text. OpenAI's Structured Outputs feature enforces a schema, whereas older JSON mode only guarantees valid JSON [14].

"Steelman." The strongest fair version of an opposing view, the opposite of a straw man [21].

"Critique and revise." A model drafting, critiquing and revising its own output improved results in one study, with no extra training [19]. Give specific criteria, or the critique stays vague.

Part B: Slash commands and built-in commands in major AI products #

Read this first.

Slash commands are product features, not part of the model. They differ by product, version, plan and sometimes by workspace [4].
I list only commands found in official vendor documentation, read on 2026-10-17. Descriptions are my own wording.
Where an official page was only partly readable or the product has no official list I could find, I say so. Third-party "cheat sheets" were not used as evidence.
Commands can change at any time, and some tools hide commands until you type their full name [1].

Product coverage summary #

Product	Slash commands found in official docs?	Where
Claude Code (terminal, IDE, desktop)	Yes, large list	[1]
ChatGPT desktop app composer (Codex-style commands)	Yes	[4]
Codex CLI	Seven named on one page; full list not read	[5]
ChatGPT on the web	Page says a separate composer command menu exists opened with `/`; contents not documented on the pages I read	[5] [VERIFY]
Gemini CLI	Yes	[6]
GitHub Copilot Chat in IDEs	Yes	[2]
GitHub Copilot CLI	Yes (partly read)	[3]
Microsoft 365 Copilot Chat	`/` opens a reference picker for files, people and more	[7]
Gemini app (consumer)	`@` mention of an app, e.g. Messages	[8]
Claude on the web (claude.ai)	No official list found	[VERIFY]
Perplexity	No official slash commands found	[VERIFY]
Grok (xAI)	Not researched in official docs; none listed	[VERIFY]

Claude Code (Anthropic) #

Source: Claude Code documentation, "Commands" [1]. Type / to see what your version offers. A command only works at the start of a message, and some are "bundled skills" or workflows that appear in the same menu. Some depend on plan or version. This is a selection of the most useful entries, not the full list.

Command	What it does	Notes
`/add-dir <path>`	Gives the session access to another folder	Most project configuration in the added folder is not auto-loaded [1]
`/agents`	Points you to managing sub-agents	In older versions it opened a UI [1]
`/autocompact`	Sets how full the context gets before automatic compaction	Accepts a size or `auto` [1]
`/background [prompt]`	Detaches the session to run in the background	Monitor from the agents view [1]
`/batch <instruction>`	Plans and runs a large change across many files in parallel	Bundled skill; splits into roughly 5 to 30 units [1]
`/branch [name]`	Forks the conversation at this point	Original is preserved [1]
`/btw [question]`	Asks a side question without adding it to the conversation	Keeps context clean [1]
`/bug`, `/feedback`	Reports a bug or sends feedback	Asks consent before sending history [1]
`/cd <path>`	Moves the session to another working directory	Keeps the conversation [1]
`/clear [name]`	Starts a new conversation with empty context	Use between unrelated tasks [1][25]
`/code-review`, `/review`	Reviews the current diff, a PR, branch or path	Bundled skill; effort levels and `--fix`, `--comment` options [1]
`/compact [instructions]`	Summarises the conversation to free context	Optional focus instructions [1]
`/config`	Opens settings (theme, model, output style)	Accepts `key=value` [1]
`/context`	Shows what is using the context window	[1]
`/copy [N]`	Copies the last (or Nth-latest) response	[1]
`/cost`, `/stats`, `/usage`	Shows cost, plan limits and activity	`/cost` and `/stats` are aliases for `/usage` [1]
`/deep-research <question>`	Runs a multi-source research workflow with a cited report	Listed as a workflow [1]
`/diff`	Reviews uncommitted changes	[1]
`/doctor`	Diagnoses setup and CLAUDE.md problems	Bundled skill [1]
`/effort [level]`	Sets reasoning effort	Levels from low to max; `auto` and `status` [1]
`/exit` (alias `/quit`)	Leaves the CLI	[1]
`/export [file]`	Exports the conversation as plain text	[1]
`/fast [on\|off]`	Toggles fast mode	[1]
`/focus`	Toggles a condensed view	[1]
`/fork [prompt]`	Copies the conversation into a new background session	[1]
`/goal [condition\|clear]`	Keeps working across turns until a stated condition is met	Shows the current goal with no argument [1]
`/help`	Shows help and commands	[1]
`/hooks`	Shows configured hooks	[1]
`/ide`	Manages IDE integration	[1]
`/import [codex\|gemini\|cursor]`	Brings configuration from other tools	Supports `--dry-run` [1]
`/init`	Creates a starter `CLAUDE.md` for the project	[1][25]
`/insights`	Generates a report on your recent sessions	Not in cloud sessions [1]
`/install-github-app`	Installs the Claude GitHub App for a repository	[1]
`/keybindings`	Opens the shortcuts file	[1]
`/list-agents`	Lists agents and sessions Claude can message	[1]
`/login`, `/logout`	Sign in or out	[1]
`/loop [interval] [prompt]`	Repeats a prompt while the session is open	Bundled skill; can self-pace [1]
`/mcp`	Manages MCP server connections and sign-in	[1]
`/memory`	Edits CLAUDE.md files and auto-memory settings	[1]
`/model [model]`	Switches model and saves it as default	[1]
`/output-style [style]`	Lists or switches output styles	[1]
`/permissions`	Manages allow, ask and deny rules	[1][13]
`/plan [description]`	Enters plan mode	Explore and propose without editing [1]
`/plugin`	Manages plugins	[1]
`/privacy-settings`	Views and updates privacy settings	Limited to some plans [1]
`/recap`	One-line summary of the session	[1]
`/release-notes`	Shows the changelog	[1]
`/reload-plugins`, `/reload-skills`	Reloads plugins or skills without restarting	[1]
`/remote-control`	Makes the session available from claude.ai	Needs a subscription [1]
`/rename [name]`	Renames the session	[1]
`/resume [session]`	Resumes a past session	Picker if no argument [1]
`/rewind` (aliases `/checkpoint`, `/undo`)	Rolls back conversation and/or code	Covers file edits made by the tools, not remote actions [1]
`/sandbox`	Toggles sandbox mode	Platform dependent [1]
`/schedule`	Creates and manages scheduled cloud routines	[1]
`/security-review`	Checks branch changes for vulnerabilities	[1]
`/simplify [target]`	Reviews changed code for cleanup and applies fixes	Bundled skill [1]
`/skills`	Lists available skills	[1]
`/status`	Shows version, model, account and connectivity	[1]
`/statusline`	Configures the status line	[1]
`/subtask <task>`	Starts a background forked sub-agent	Result returns to the session [1]
`/tasks`	Views background work	Alias `/bashes` [1]
`/terminal-setup`	Sets up multi-line input key bindings	[1]
`/theme`	Changes the colour theme	[1]
`/tui [default\|fullscreen]`	Chooses the terminal renderer	[1]
`/ultrareview [PR or branch]`	Deep multi-agent review in a cloud sandbox	[1]
`/verify`	Builds, runs and observes the app to confirm a change works	Bundled skill [1]
`/voice`	Toggles voice dictation	Requires an account [1]
`/workflows`	Opens the workflow progress view	[1]

Removed or changed (per the same page): /pr-comments and /vim are marked removed, and /ultraplan is marked removed in favour of plan mode [1].

ChatGPT desktop app composer (OpenAI) #

Source: OpenAI "Slash commands" page on ChatGPT Learn [4]. The page describes commands typed in the chat composer of the ChatGPT desktop app, with commands varying by environment and access. It also says enabled skills appear in the list, custom prompts appear as /prompts:<name>, and skills can be invoked with $ [4].

Command	What it does	Notes
`/approve`	Approves one retry of a recent automatic-review denial	Only when automatic review is active [4]
`/archive`	Archives the current chat	[4]
`/chat`	Chooses a chat without a project before starting a new one	[4]
`/cloud`, `/cloud-environment`	Runs the chat in the cloud; picks its cloud environment	When available [4]
`/compact`	Compacts the chat's context	[4]
`/fast`	Toggles a Fast service tier	When available [4]
`/feedback`	Opens the feedback dialog	Optionally with logs [4]
`/fork`	Copies a local chat into a new chat or worktree	[4]
`/goal`	Sets a persistent goal	[4]
`/ide-context`	Turns shared IDE context on or off	[4]
`/init`	Generates an `AGENTS.md` scaffold	[4]
`/local`	Runs the chat in the selected local project	[4]
`/mcp`	Shows connected MCP servers	[4]
`/memories`	Configures memory use and generation	When available [4]
`/model`	Chooses the model for this chat	[4]
`/new`	Starts a blank chat in the same workspace	When available [4]
`/pet`	Wakes or tucks away the desktop pet	[4]
`/pin`	Pins or unpins the chat	When available [4]
`/plan`	Toggles plan mode for multi-step planning	[4]
`/project`	Chooses the project for new chats	[4]
`/reasoning`	Chooses reasoning effort	[4]
`/rename`	Renames the chat	[4]
`/review`	Starts code review mode	Uncommitted changes or against a base branch [4]
`/side`	Starts a temporary side chat	[4]
`/status`	Shows chat ID, context use and rate limits	[4]
`/usage`	Opens usage and billing settings	With ChatGPT sign-in [4]
`/worktree`	Runs the chat in a new Git worktree	[4]

Codex CLI. OpenAI's "Developer commands" page names /feedback, /goal, /init, /mcp, /plan, /review and /status as slash commands, and says the Codex slash commands do not apply on ChatGPT web, which has its own composer menu opened with / [5]. I did not read a full CLI slash list. [VERIFY]

ChatGPT on the web. The page above confirms a composer command menu exists but does not list it [5]; I could not find an official list. [VERIFY] by typing / in the message box.

Gemini CLI (Google) #

Source: Gemini CLI docs "CLI commands", last updated 2026-10-09 per the page [6]. Note: the same page states that Gemini CLI was replaced by Antigravity CLI on 2026-06-18 [6], so check which tool you are using. [VERIFY]

Command	What it does	Notes
`/about`	Shows version information	[6]
`/agents`	Manages local and remote sub-agents	list, reload, enable, disable, config [6]
`/auth`	Changes the authentication method	[6]
`/bug`	Files a GitHub issue	[6]
`/chat`	Alias of `/resume`	Sessions and checkpoints [6]
`/clear`	Clears context and the terminal; new session	[6]
`/commands`	Lists or reloads custom commands from `.toml` files	[6]
`/compress`	Replaces context with a summary	[6]
`/copy`	Copies the last output	[6]
`/directory` (`/dir`)	Adds or shows workspace folders	[6]
`/docs`	Opens the documentation	[6]
`/editor`	Chooses an editor	[6]
`/extensions`	Manages extensions	[6]
`/help` (`/?`)	Shows help	[6]
`/hooks`	Enables, disables or lists hooks	[6]
`/ide`	Manages IDE integration	[6]
`/init`	Generates a `GEMINI.md` context file	[6]
`/mcp`	Manages MCP servers and tools	[6]
`/memory`	Shows, refreshes or lists memory	[6]
`/model`	Opens model configuration or sets the model	[6]
`/permissions`	Manages folder trust	[6]
`/plan`	Switches to read-only plan mode	[6]
`/policies`	Lists active policies	[6]
`/privacy`	Shows the privacy notice and consent choice	[6]
`/quit` (`/exit`)	Exits	`--delete` also removes session history [6]
`/restore`	Restores project files to their state before a tool ran	[6]
`/resume`	Browses and resumes saved sessions	[6]
`/rewind`	Steps back through history and can revert changes	[6]
`/settings`	Opens the settings editor	[6]
`/shells` (`/bashes`)	Toggles the background shells view	[6]
`/skills`	Lists, enables, disables or reloads Agent Skills	[6]
`/stats`	Shows usage statistics	[6]
`/theme`	Changes the theme	[6]
`/tools`	Lists available tools	[6]
`/vim`	Toggles vim-style editing	[6]

Other input forms on that page: @<path> inserts a file or folder reference, and !<command> runs a shell command [6].

GitHub Copilot Chat (GitHub) #

Source: GitHub "Copilot Chat cheat sheet" [2]. Commands differ by environment.

Environment	Command	What it does
GitHub website	`/clear`, `/delete`, `/new`, `/rename`	Clears, deletes, starts or renames a conversation
Visual Studio Code	`/clear`	Starts a new chat session
Visual Studio Code	`/explain`	Explains the code in the active editor
Visual Studio Code	`/fix`	Proposes a fix for problems in selected code
Visual Studio Code	`/fixTestFailure`	Finds and fixes a failing test
Visual Studio Code	`/help`	Quick reference
Visual Studio Code	`/new`	Creates a new project
Visual Studio Code	`/tests`	Generates unit tests for selected code
Visual Studio	`/doc`, `/explain`, `/fix`, `/help`, `/optimize`, `/tests`	Doc comment, explain, fix, help, performance improvement, tests
JetBrains	`/explain`, `/fix`, `/help`, `/tests` and CLI-session commands `/chronicle`, `/compact`, `/remote`	See the page for details
Xcode	`/doc`, `/explain`, `/fix`, `/simplify`, `/tests`	Docs, explain, fix, simplify, tests

The same page lists VS Code chat participants @azure, @github, @terminal, @vscode, and variables such as #file, #selection, #project and #sym [2].

GitHub Copilot CLI (GitHub) #

Source: GitHub "Copilot CLI command reference" [3]. The page is very long and my read covered only the start of the slash-command table, so the list below is incomplete. [VERIFY] the rest in the live page or with /help.

Command	What it does	Notes
`/add-dir PATH`	Grants file access to a directory	Loads its skills and agents as trusted [3]
`/agent`	Browses and selects a custom agent	[3]
`/app`	Opens the session in the GitHub Copilot app	[3]
`/ask`, `/btw`	Asks a quick side question	Not added to history [3]
`/allow-all`, `/yolo`	Enables all permissions	Alias of a permissions option; use with care [3]
`/autopilot`, `/goal`	Starts or refocuses autopilot mode with an objective	[3]
`/changelog`, `/release-notes`	Shows the CLI changelog	[3]
`/clear`, `/new`, `/reset`	Starts a new conversation	`/new worktree` uses a new Git worktree [3]
`/compact`	Summarises the conversation to save context	[3]
`/context`	Listed; description not read	[VERIFY]

Input conventions: @ FILENAME adds a file to context, ! COMMAND runs a local shell command, # NUMBER includes an issue or pull request [3].

Microsoft 365 Copilot Chat (Microsoft) #

Source: Microsoft Support, "Refer to specific files and more" [7]. Typing / followed by a name opens a reference menu with tabs. With Work IQ on and a Copilot licence, you can reference people, files, meetings, emails, Teams chats and channels, and SharePoint sites; without it, you can reference only files plus permitted public web information. Results follow the user's existing permissions, and a limit of ten files or pages applies within each SharePoint site [7]. Microsoft's separate guide recommends structuring prompts as goal, context, source and expectations [24].

Gemini app (Google) #

Google's Gemini Apps Help states that if Gemini does not use an app on its own, you can add @Messages to the prompt to name it (example for the Messages app on Android) [8]. I did not find an official general list of @ apps. [VERIFY]

Claude (web and apps), Perplexity, Grok #

I did not find an official command list for the consumer chat apps of Claude, Perplexity or Grok. Third-party sites describe slash palettes and focus-mode shortcuts, but these conflict with each other and are not confirmed by the vendors, so they are omitted. [VERIFY] with each product's help centre.

Common mistakes #

Mistake	Why it matters	Fix
Treating Part A words as magic keywords	They are ordinary language; results depend on context	Pair each command with audience, format, limit, source
Assuming a slash command from one tool works in another	Commands are product-specific, and names collide (`/init`, `/plan`, `/compact` mean different things) [1][3][4][6]	Check the tool's own `/help`
Copying a command list from a blog	Lists go stale quickly	Use the official docs
Using step-by-step wording on reasoning models	Vendors advise against it [13][15]	Give goals and constraints; check the model page
Asking for citations without providing sources	Models can invent references [11]	Provide documents or enable search; verify
Running powerful agent commands unreviewed	Commands like "allow all" remove approvals [3]	Use allowlists and review changes
Trusting "Fact-check" without sources	A model cannot verify unseen facts	Supply sources or use a search tool

Checklist #

[ ] I picked the command word that matches my real goal (change, judge, create, explain, control).
[ ] I added audience, format, length and source.
[ ] I said what to do if information is missing.
[ ] For slash commands: I checked the tool's own /help and its documentation date.
[ ] I did not paste secrets into a prompt or a shared session.
[ ] I reviewed the output before using it.

Glossary #

Command word: a verb in a prompt that tells the model what operation to perform.
Slash command: a command starting with / that a software tool interprets (not the model).
Composer: the message input area of a chat app.
Skill: a packaged set of instructions a tool can load on demand.
Alias: another name for the same command.
Plan mode: a tool mode where the assistant proposes a plan without making changes.
Context window: the amount of text the model can consider at once.
Compaction: summarising earlier conversation to free space.
Grounding: basing answers on supplied sources.
Structured output: output that must match a schema such as JSON.
MCP: Model Context Protocol, a standard for connecting AI tools to data and services.

Sources #

All accessed 2026-10-17. Dates are shown only where the page gave one.

Commands. Claude Code documentation, Anthropic. https://code.claude.com/docs/en/commands (no date shown)
GitHub Copilot Chat cheat sheet. GitHub Docs. https://docs.github.com/en/copilot/reference/chat-cheat-sheet (no date shown)
GitHub Copilot CLI command reference. GitHub Docs. https://docs.github.com/en/copilot/reference/copilot-cli-reference/cli-command-reference (no date shown; partly read)
Slash commands. ChatGPT Learn, OpenAI. https://learn.chatgpt.com/docs/reference/slash-commands (no date shown)
Developer commands. ChatGPT Learn, OpenAI. https://learn.chatgpt.com/docs/developer-commands?surface=cli (no date shown; partly read)
CLI commands. Gemini CLI documentation. https://geminicli.com/docs/reference/commands/ (last updated 2026-10-09)
Refer to specific files and more in Microsoft Copilot. Microsoft Support. https://support.microsoft.com/en-US/Microsoft-365-Copilot/refer-to-specific-files-and-more-in-microsoft-365-copilot (no date shown)
Send messages with the Gemini mobile app on Android. Gemini Apps Help, Google. https://support.google.com/gemini/answer/15574940 (no date shown)
Prompting best practices. Anthropic docs. https://platform.claude.com/docs/en/build-with-claude/prompt-engineering/claude-prompting-best-practices (no date shown)
Best practices for prompt engineering for 2026. Anthropic. https://claude.com/blog/best-practices-for-prompt-engineering (2025-11-10)
Reduce hallucinations. Anthropic docs. https://platform.claude.com/docs/en/test-and-evaluate/strengthen-guardrails/reduce-hallucinations (no date shown)
Prompt engineering. OpenAI. https://developers.openai.com/api/docs/guides/prompt-engineering (no date shown)
Reasoning best practices. OpenAI. https://developers.openai.com/api/docs/guides/reasoning-best-practices (no date shown)
Structured model outputs. OpenAI. https://developers.openai.com/api/docs/guides/structured-outputs (no date shown)
Prompt engineering techniques. Microsoft Learn. https://learn.microsoft.com/en-us/azure/foundry/openai/concepts/prompt-engineering (updated 2026-06-05)
Prompt design strategies. Google AI for Developers. https://ai.google.dev/gemini-api/docs/prompting-strategies (last updated 2026-10-13)
Wei et al. Chain-of-Thought Prompting Elicits Reasoning in Large Language Models. arXiv. https://arxiv.org/abs/2201.11903 (2022)
Kojima et al. Large Language Models are Zero-Shot Reasoners. arXiv. https://arxiv.org/abs/2205.11916 (2022)
Madaan et al. Self-Refine: Iterative Refinement with Self-Feedback. arXiv. https://arxiv.org/abs/2303.17651 (2023)
Schulhoff et al. The Prompt Report. arXiv. https://arxiv.org/abs/2406.06608 (2024)
Straw man. Wikipedia. https://en.wikipedia.org/wiki/Straw_man (no date shown)
Define success criteria and build evaluations. Anthropic docs. https://platform.claude.com/docs/en/test-and-evaluate/develop-tests (no date shown)
Designing reliable evals for LLM applications. OpenAI. https://developers.openai.com/api/docs/guides/evaluation-best-practices (no date shown)
Get started writing prompts in Microsoft Copilot. Microsoft Support. https://support.microsoft.com/en-us/topic/learn-about-copilot-prompts-f6c3b467-f07c-4db1-ae54-ffac96184dd5 (updated September 2026)
Best practices for Claude Code. Claude Code documentation. https://code.claude.com/docs/en/best-practices (no date shown)

Last updated: 2026-10-17