Loading...
Loading...
After months of using Claude Code as my daily driver, these are the keyboard shortcuts, slash commands, and workflows that actually matter. No fluff — just the ones I reach for 50+ times a day.
Here's the thing — Claude Code is insanely powerful. But most devs use it like a fancy chatbot. Type question. Get answer. Copy paste. Repeat.
That's like buying a Ferrari and only driving it in first gear.
I've been using Claude Code as my primary development tool for months now, and I went from "this is cool" to "I literally cannot code without this anymore." The difference? Shortcuts.
Not all of them — there are like 100+ shortcuts and slash commands. Most of them you'll never need. But there's a core set of maybe 15-20 that, once they're in your muscle memory, make you mass productive.
Let me show you the ones I actually use. Every. Single. Day.
These are non-negotiable. If you learn nothing else from this post, learn these.
| Shortcut | What It Does | Why I Love It |
|----------|-------------|---------------|
| Shift+Tab | Cycle permission modes | Switch between default → acceptEdits → plan → auto in ONE keystroke. No more clicking through dialogs. |
| Ctrl+R | Reverse search history | Just like your terminal! Start typing and it finds matching previous prompts. Game changer when you're iterating. |
| Ctrl+C | Cancel generation | When Claude goes on a tangent (we've all been there 😅), kill it instantly and redirect. |
| Ctrl+O | Toggle transcript viewer | See EXACTLY what tools Claude used, what files it read, what edits it made. Debugging Claude itself. |
| Up/Down arrows | Navigate prompt history | Reuse and modify previous prompts. I use this probably 50+ times a day. |
| @ + filename | File path autocomplete | Type @src/comp... and it autocompletes. No more typing full paths like a caveman. |
Let me explain why this is #1. Claude Code has permission modes:
| Mode | What Happens | When I Use It |
|------|-------------|---------------|
| Default | Asks before every file edit | When exploring unfamiliar code |
| Accept Edits | Auto-approves file changes, still asks for commands | My normal mode — 80% of the time |
| Plan | Claude only plans, doesn't execute | When I want to review approach before committing |
| Auto | Full autopilot — does everything | When I trust the task and want to go make coffee ☕ |
Before I knew Shift+Tab, I was manually going to settings every time. Now I just tap Shift+Tab twice and I'm in auto mode. Task done. Tap back to default. 2 seconds.
There are like 60+ slash commands. I use about 10 regularly. Here's my honest ranking:
| Command | What It Does | My Use Case |
|---------|-------------|-------------|
| /clear | Wipe conversation, free context | When context gets bloated after a big task. Fresh start. |
| /compact | Compress conversation smartly | When I want to keep context but it's getting heavy. Add focus: /compact focus on the auth refactor |
| /model | Switch AI model | Hop between Opus (complex tasks) and Sonnet (quick stuff) without leaving the session |
| /diff | Interactive diff viewer | Review ALL changes Claude made — way better than git diff for understanding what happened |
| Command | What It Does | My Use Case |
|---------|-------------|-------------|
| /cost | Show token usage | Keeping tabs on how much context I'm burning. Useful before deciding to /clear or /compact |
| /context | Visual context grid | Beautiful colored grid showing context usage. Tells you exactly when you're running low |
| /resume | Resume previous session | Pick up yesterday's work exactly where I left off. Claude remembers everything. |
| /plan | Enter plan mode | "Hey Claude, plan the auth migration but DON'T touch any code yet." Perfect for complex tasks. |
| Command | What It Does | My Use Case |
|---------|-------------|-------------|
| /batch | Parallel multi-file changes | Refactoring 20 files at once? This spawns parallel agents in git worktrees. Absolute beast. |
| /memory | Edit CLAUDE.md | Teaching Claude my preferences so it stops suggesting things I hate |
| /export | Save conversation | When I want to keep a record of a particularly good debugging session |
When you're typing a long prompt and realize you need to restructure it... these are lifesavers:
| Shortcut | What It Does | The Real Scenario |
|----------|-------------|-------------------|
| Ctrl+G | Open prompt in your editor | Long prompt? Pop it open in VS Code, edit comfortably, save, and it's back in Claude. Chef's kiss. 👨🍳 |
| Ctrl+K | Delete to end of line | "No wait, I don't want the second half of this sentence" — gone in one keystroke |
| Ctrl+U | Delete to start of line | "Actually scratch that whole line" — boom, cleared |
| Ctrl+Y | Paste deleted text back | "Wait no, I did want that" — undo delete. Readline magic. |
| \ + Enter | Multiline input | Write multi-paragraph prompts without accidentally sending halfway through |
Most people don't know about Ctrl+G. Here's when I use it:
You're writing a detailed prompt with code examples, specific file references, and multi-step instructions. The terminal input is getting cramped. Hit `Ctrl+G` — your full `$EDITOR` opens with the prompt. Edit it properly. Save and close. The prompt is back in Claude, perfectly formatted.
I use this at least 3-4 times a day for complex prompts. It's the difference between a mediocre prompt and a precision-guided missile.
This one blew my mind when I discovered it.
Type ! before any command and it runs directly in your shell — output goes straight into Claude's context.
Normally, if you want Claude to see your build errors, you'd copy-paste them. With !:
No copy-paste. No screenshots. No "here's my error" preamble. Just ! and go.
Then: "Review these changes before I commit."
Claude sees exactly what you're about to commit and gives you a code review. Free. Instant. Every time.
Here's the truth: most Claude Code frustrations come from bad context management. Claude starts giving weird answers? Context is bloated. Claude forgets what you said 5 minutes ago? Context was compacted poorly.
Here's my system:
| Command | What It Shows | Action I Take |
|---------|--------------|---------------|
| /context | Colored grid of context usage | If >70% full → /compact |
| /cost | Token count breakdown | If >100K tokens → consider /clear |
| /compact [focus] | Compress with instructions | /compact keep the blog automation code and sanity setup context |
| /clear | Nuclear option | When starting a completely new task |
Don't just run /compact naked. Tell it what matters:
This keeps the relevant context and dumps the noise. It's like defragmenting your Claude session.
These are the ones in my muscle memory — I don't even consciously think about pressing them anymore:
| Shortcut | What It Toggles | When |
|----------|----------------|------|
| Option+O (Mac) / Alt+O | Fast mode on/off | Quick questions → fast mode ON. Complex refactors → fast mode OFF. |
| Option+T (Mac) / Alt+T | Extended thinking | Turn ON for architecture decisions, complex bugs. Turn OFF for simple tasks. |
| Option+P (Mac) / Alt+P | Switch model | Opus for hard stuff. Sonnet for quick stuff. Mid-prompt, no restart needed. |
| Ctrl+T | Toggle task list | Check on background agents without leaving my current prompt |
My typical flow:
Same model (Opus), but fast mode skips the deep thinking. Perfect for "what's the import path for X" type questions.
| Command | My Workflow |
|---------|-------------|
| /resume | Monday morning → /resume → pick up Friday's auth refactor exactly where I left off |
| /rename auth-migration | Give sessions meaningful names so I can find them later |
| /branch | "Let me try a different approach" → branch the conversation, experiment, keep the original safe |
| /export session.md | Save important debugging sessions for future reference |
I used to start fresh every session. Huge mistake. Now:
Claude remembers every file it read, every edit it made, every decision we discussed. It's like having a team member with perfect memory.
Here's roughly how many times I use each shortcut on a typical coding day:
| Shortcut | Daily Usage | Category |
|----------|------------|----------|
| Up/Down arrows | ~60 times | History navigation |
| @ file reference | ~40 times | File path autocomplete |
| Shift+Tab | ~20 times | Permission mode cycling |
| ! command | ~15 times | Bash mode |
| /compact | ~5 times | Context management |
| Ctrl+R | ~5 times | History search |
| Ctrl+C | ~5 times | Cancel generation |
| Ctrl+G | ~3 times | External editor |
| Option+O | ~8 times | Fast mode toggle |
| /diff | ~3 times | Review changes |
| /clear | ~2 times | Fresh start |
| /model | ~2 times | Switch model |
| /resume | ~1 time | Continue previous session |
Total: ~170+ shortcut uses per day. And I'm probably underounting.
Here's my actual workflow for a typical feature implementation:
10 steps. What used to take me 2-3 hours takes 20-30 minutes. And the code quality is usually better because Claude catches things I'd miss.
| Feature | How | Mind-Blown Rating |
|---------|-----|-------------------|
| Paste images | Ctrl+V / Cmd+V to paste screenshots directly into prompt | 🤯🤯🤯 |
| Voice input | Hold Space for push-to-talk dictation | 🤯🤯 |
| Auto-fix PRs | /autofix-pr watches your PR and pushes fixes when CI fails | 🤯🤯🤯🤯 |
| Custom status line | /statusline auto-configures from your shell prompt | 🤯 |
| Rewind time | Esc + Esc reverts code AND conversation to any previous point | 🤯🤯🤯 |
| Parallel refactoring | /batch "rename userId to user_id across all files" spawns parallel agents | 🤯🤯🤯 |
This one deserves special mention. Ever had Claude make changes you didn't want? Instead of manually reverting:
It's literally time travel for your codebase. I use this more than I'd like to admit.
Print this. Tape it to your monitor. Thank me later.
Essential Shortcuts:
Essential Commands:
The Golden Rule: Learn Shift+Tab and ! prefix first. Everything else is optimization on top.
Look, I'm not saying shortcuts will make you a 10x developer overnight. But they remove friction. And friction is the silent killer of productivity.
Every time you reach for the mouse, every time you copy-paste an error message, every time you manually switch modes — that's friction. These shortcuts eliminate it.
Start with the "Can't Live Without" tier. Use them for a week. Then come back and learn the next tier. In a month, you'll wonder how you ever coded without them.
Now if you'll excuse me, I need to go ! npm run build something. 🚀
Have a shortcut I missed? Or a workflow that's even faster? I'd love to hear about it. Drop a comment or reach out — always looking to level up.