Cheat Sheet: Slash Commands & Shortcuts

Once you launch codex in a project directory, everything you do happens through one text composer — but that composer speaks two different keyboards at once, and keeping them straight is the whole game.

• Slash commands (/…) drive Codex the system — switch models, set permissions, review a diff, compact the conversation, browse skills. Type / to open a filterable popup of everything available right now.
• Keyboard shortcuts (Ctrl+…, Esc, Tab) drive the session itself — cancel a turn, search history, queue a follow-up, edit your last message. These never appear in the popup; you have to know them.
• Composer modifiers (@, !, image paste) are a third, smaller set that shape a single message before you send it — pull in a file path, run a shell command inline, drop in a screenshot.

The reason this lesson exists as a reference is that the slash roster is large and changes often — new commands land, others get renamed. So treat the tables below as a map of what categories exist and what they're for, and treat the live page — developers.openai.com/codex/cli/slash-commands — as the source of truth for the exact current set. Learn the shape; verify the specifics.

These are the commands you'll reach for many times a day — the core loop of starting, steering, reviewing, and managing a session. Type / and start typing to filter.

A few distinctions worth burning in, because they look similar but aren't:

• /clear vs /new — /clear wipes the terminal and starts a fresh chat; /new starts a new conversation but stays inside the same running CLI session. (And neither is the same as the Ctrl+L key, which only repaints the screen — more on that below.)
• /compact vs /clear — /compact summarizes the current conversation to reclaim context tokens while keeping continuity; /clear throws the conversation away.
• /resume vs /fork — /resume continues an existing thread (it appends to the same session); /fork branches a new thread that preserves the original transcript, so you can explore without disturbing the original.

Beyond the core loop, a second tier of slashes reaches Codex's surrounding systems — MCP tools, skills, plugins, hooks, connectors, memory, IDE context — plus a handful of purely cosmetic ones.

Extension / systems:

Cosmetic / personalization:

There are more — /experimental, /raw, /side (alias /btw), /ps, /stop, /feedback, /debug-config, /logout, /exit//quit, and Windows-only /sandbox-add-read-dir. Don't memorize the long tail; just remember that if a capability has a home in Codex, there's probably a slash for it, and the popup will surface it.

Codex moves fast, and the internet is full of stale cheat sheets. Two specific gotchas trip up nearly everyone coming from an older guide or from Claude Code.

1. /approvals is gone — it's /permissions now. Older docs and muscle memory say /approvals to change what Codex can do without asking. The current command is /permissions ("Set what Codex can do without asking first"). /approvals no longer appears in the slash popup as its own entry. Just use /permissions.

2. There is no /undo. This is the big one. Codex deliberately does not ship an /undo slash command. Instead, rollback happens through your normal git workflow — Codex always surfaces a transcript of every action it took, so you can see exactly what changed and revert it with git.

# Codex made changes you want to back out — use git, not a slash command
git status            # see what changed
git diff              # inspect the changes
git restore .         # discard unstaged edits to tracked files
git checkout -- path  # revert a specific file

The practical takeaway: work in a clean git tree so that "undo" is always one git restore away. The transcript tells you what happened; git is how you reverse it.

This is a real difference from Claude Code, which has session checkpoints you reach with Esc Esc / /rewind. In Codex, Esc Esc does something else entirely (it edits your previous message — see the keys section), and there's no built-in checkpoint stack. Git is your safety net.

Shortcuts drive the session, never show up in the slash popup, and are where the Codex-specific reflexes live. The single most important one to get right: interrupt is Ctrl+C, not Esc.

The pairs that confuse people:

• Ctrl+C vs Esc Esc. Ctrl+C interrupts the running turn. Esc Esc (when the composer is empty) edits your previous message and lets you walk back through the transcript — pressing Enter from an earlier point forks the conversation. They are not interchangeable.
• Ctrl+L vs /clear. Ctrl+L just repaints the screen; the conversation is intact. /clear actually starts a fresh chat. Use Ctrl+L when scrollback is messy but you want to keep going.
• Tab vs Enter while Codex runs. Tab queues input for after the current turn; Enter injects it into the current turn immediately. Queue when you want it to finish first; inject when you need to course-correct now.

Three modifiers shape a single message before you send it. They're how you feed Codex context without leaving the composer.

@ — fuzzy file search. Type @ to open a fuzzy search over the workspace root. Start typing a filename, then press Tab or Enter to drop the highlighted path into your message. This is the fast way to point Codex at a specific file.

Fix the validation bug in @src/auth/login.ts and update @tests/login.test.ts

! — inline shell command. Prefix a line with ! to run a local shell command and feed its output into the conversation as context. Great for showing Codex the current state without describing it.

!ls src/components
!git log --oneline -5

Image paste. Paste a screenshot or design spec directly into the composer — useful for a stack trace, a failing UI, or a mockup. (From outside the session you can also attach images at launch with codex -i screenshot.png "Explain this error"; -i/--image takes comma-separated or repeated files.)

Ctrl+T — transcript overlay. Not a composer modifier exactly, but it lives in the same flow: Ctrl+T opens (and closes) the transcript overlay, the scrollable record of everything Codex did this session. Its keymap action is open_transcript, default binding ctrl-t. This is also where you confirm what happened before you reach for git to undo it.

# Attach images when launching, not just by pasting:
codex -i error.png,mockup.png "Make the page match the mockup and fix this error"

None of these bindings are fixed. /keymap remaps TUI shortcuts interactively and persists your choices to the [tui.keymap] section of config.toml (under CODEX_HOME, default ~/.codex/). That means your remaps survive restarts and travel with your config.

The config is grouped by where a binding applies — global, composer, chat:

[tui.keymap.global]
open_transcript = "ctrl-t"

[tui.keymap.composer]
submit = ["enter", "ctrl-m"]   # a binding can have multiple keys

[tui.keymap.chat]
interrupt_turn = "f12"          # e.g. move interrupt off Ctrl+C

A binding can map to a list of keys (any of them triggers the action), as submit shows above. So if Ctrl+C for interrupt fights with your terminal habits, you can rebind interrupt_turn — but do it deliberately, since interrupt is the one shortcut you most need to find in a hurry.

Finally, the standing reminder for this whole lesson: the slash roster and some bindings are volatile. When a command in an old cheat sheet doesn't appear in your popup, don't assume you're wrong — assume the roster moved. Check the live page.

Live source of truth (bookmark it):
https://developers.openai.com/codex/cli/slash-commands