Claude Code shortcuts Plan Mode users should know: Shift+Tab and daily commands

For additional instructions on working with Ailoot, see the documentation.

Which shortcuts and commands does this Claude Code guide cover?#

With vibe coding, the question is no longer “does Claude Code work?” - the question is “how do you work with it so it doesn't burn through your limits or hallucinate?” My 9 previous guides cover the concepts: CLAUDE.md, Plan Mode, context engineering, Skills, Subagents, MCP, /rewind, limits, second brain. This one is a collection of tactics to go with them.

Each tip solves one headache. You can read them in order or jump to the most pressing ones: for shortcuts, go straight to tip 1; for saving tokens, tips 4 and 5; for parallel work, tip 6; for the author's techniques, tips 8-11.

I'm writing for people who have already installed Claude Code and spent at least a week using it. If you're just installing it, start with the CLAUDE.md guide, then come back.

How to switch Claude Code modes: the Shift+Tab shortcut#

The most common beginner mistake is staying in default all day and manually approving every change. After an hour, this gets exhausting, and you're tempted to run --dangerously-skip-permissions (more on that at the end of the tip). Shift+Tab is the middle ground: you choose when you need acceptEdits and when you need plan.

Here's the specific rule I follow when switching:

1. Starting a complex task - use Shift+Tab until the mode indicator shows plan. Claude thinks it through and drafts a plan; it doesn't write code until I approve.
2. Plan approved, moving to implementation - cycle until the mode indicator shows acceptEdits. Claude edits files without asking for approval, but still prompts for Bash commands.
3. Routine edits (rename, trivial refactoring) - go straight to acceptEdits, no plan.
4. Danger zone (database migrations, deleting files) - I return to default with Shift+Tab.

# Common permission modes (check the active label, not a fixed press count):
# default        - standard permission prompts
# acceptEdits    - file edits are accepted; other tool permissions still apply
# plan           - investigate and plan before implementation
# Additional modes depend on your version, settings, and organization policy.

If Shift+Tab doesn't work in your version of Claude Code (claude --version), check that you have the latest version. The /doctor command will show you everything about the installation.

How to undo the last action without losing context: Esc Esc#

Esc and Esc Esc do different things, which is why people mix them up:

• One Esc - interrupts Claude in the moment, while it's doing something. Everything it has managed to do remains. Useful when it's gone in the wrong direction and you want to redirect it.
• Double Esc Esc - if the input field is empty, opens the checkpoint menu (restore code, restore conversation, or both, or summarize). If there's text in the field, it clears the field and puts the text in history (the up arrow brings it back).

# From the Esc Esc menu with an empty field:
# 1. Restore code only            - restore the files, leave the conversation
# 2. Restore conversation only    - restore the conversation, leave the files
# 3. Restore code and conversation - restore both (the most common choice)
# 4. Summarize from here          - summarize the conversation from this point
# 5. Summarize up to here         - summarize up to this point

Checkpoints are created automatically for every prompt you send - there's nothing to remember, and you can always go back. For the full breakdown, see the guide to /rewind, which also covers the git combination for deep rollbacks.

Esc Esc is one of the first techniques for beginners. Once they stop being afraid that they'll “break it and won't be able to undo it,” they start experimenting more boldly, and the results improve many times over.

When should you use /compact instead of /clear?#

Here's how /compact works internally: Claude takes the entire message history, processes it, and returns a brief summary with the most important details. A useful trick is to give it a hint: /compact keep the coding principles and current plan, discard the CSS discussion. Then the compression will be targeted.

# When to use what:
/clear                              # finished a feature, moving to a new one
/compact                            # long session, context is >50% full
/compact keep the architecture and plan  # targeted compression with a focus

The signal that it's time for /compact: the /cost command or status bar shows 70%+ of the context window used, and the session is only half over. If you ignore this, Claude will start “forgetting” the beginning of the conversation, and you'll waste time explaining things again.

For the full theory of the context window, see the guide to context engineering. It also explains why context is a finite resource with diminishing returns.

How to track tokens in real time: the /cost command#

The fear of “spending it all in one day” is one of the top concerns among vibe coders. The main way to address that fear is to make spending visible.

/cost          # shows current session spending (tokens + $)
/statusline    # configures the status bar: model + directory + context % + cost

A simple rule: check /cost every 30-60 minutes. If you've spent less than a couple of dollars in an hour, that's fine. If it's more, something's off: maybe you forgot /compact and the context is growing, maybe you chose the wrong model (more on that in the next tip), or maybe Claude is rereading large files 10 times.

The full guide to saving on limits is “How Not to Burn Through Claude Code Limits in a Day”, with 8 rules. Here, the tactic is making spending visible with /cost and /statusline.

Which Claude model should you choose for a task: Haiku, Sonnet, or Opus?#

claude --model haiku   # ~3× cheaper than sonnet, for routine work
claude --model sonnet  # default, balance of price and quality
claude --model opus    # ~1.7× more expensive than sonnet, for complex tasks

According to Anthropic's public pricing in May 2026: Haiku $1/$5 per 1M input/output, Sonnet $3/$15, Opus $5/$25. That means Haiku is 3 times cheaper than Sonnet, and Opus is 1.7 times more expensive than Sonnet.

How I choose every day:

The debatable point is whether to use Sonnet and Haiku at all if Opus gets it right “on the first try” on average. My answer: for a non-programmer entrepreneur, Haiku and Sonnet pay off on 70% of tasks. Opus is worth saving for the 30% that are genuinely difficult.

How to run 3-5 tasks in parallel: /resume + git worktrees#

The logic is simple: one long Claude window eats up context. Each request loads everything that was in that window into the model - even if you're discussing something completely different now. 5 short windows for micro-tasks each remember only their own work. In total, you spend less.

# Start a named session for a specific task:
claude --resume "auth-refactor"
claude --resume "homepage-redesign"
claude --resume "db-migration"

# Use a worktree to keep git from overlapping:
git worktree add ../my-project-auth feature/auth
cd ../my-project-auth
claude --resume "auth-refactor"

If you lose track of what's in each window, run claude --resume without an argument to see a list of recent sessions with their names and times. Inside an active session, /agents checks the running subagents.

When I'm working on a feature with a long development cycle, I usually do this:

1. Window 1 - plan in plans/YYYY-MM-DD-feature.md. Discussion only, no code.
2. Window 2 (following the plan) - implement phase 1. After the phase, update the plan ([x]).
3. Window 3 - implement phase 2 in parallel with window 2, if the phases don't overlap.
4. Window 4 - a synthesis agent checks the results from both windows.
5. Window 5 - a security review after merging (see tip 8).

When not to use worktrees: if you're managing 1-2 projects a day, the overhead of switching between worktree directories will eat into the benefit. Worktrees start to pay off at 3+ parallel tasks per day.

How to avoid hallucinations: file references with @file#

File autocomplete starts with the @ symbol. Start typing a path and Claude shows suggestions. You can reference several files at once: @src/lib/auth.ts @src/lib/session.ts @prisma/schema.prisma.

# Prompt without exact paths (bad):
> Look at the auth logic and fix the session bug

# Prompt with @ references (right):
> @src/lib/auth.ts @src/lib/session.ts - fix the bug: after logout the cookie isn't cleared

The second trick in the same group is shell mode using !:

> !git status                # runs without calling Claude, output goes into context
> !npm test                  # same
> !cat /var/log/app.log | tail -50  # same

Why: you don't spend tokens on “Claude, look at git status” - Claude would get the same answer through the tool anyway. ! is shorter and cheaper.

This is related to CLAUDE.md: the main file should be up to 200 lines of project rules. Narrower rules (for example, API conventions) go in .claude/rules/api-design.md with YAML frontmatter paths: ["src/api/**/*.ts"]. Then they're loaded only when Claude edits files in src/api/. For the full breakdown, see the CLAUDE.md guide.

How to avoid losing progress on long tasks: plans with phases and [ ] / [x]#

Here's the plan file template I use in every project:

# Plan: [feature name]
Creation date: 2026-05-22
Goal: [one sentence on what we want to achieve]

## Phase 1: [short name]
- [ ] Step 1.1: [specific action]
- [ ] Step 1.2: [specific action]
- [ ] Step 1.3: [specific action]

## Phase 2: [short name]
- [ ] Step 2.1
- [ ] Step 2.2

## Outcome
Fill in at the end: fully or partially implemented, and what remains.

The rule is absolute: every agent must update the plan after each session. In other words, as soon as you finish a phase, go to the file and mark it [x]. If you don't, the next window won't know the phase is done and will try to repeat it.

When the plan is in a file, not in your head:

• Parallel windows (see tip 6) can pick up different phases.
• If the task stretches over 3 days, when you return 2 days later, you can see right away where you left off.
• The final check against the actual result is cheap (grep -c "\[ \]" in the file = number left open).

When not to use it: a 5-minute hotfix, a trivial edit in one file, reading and summarizing a log. Not every action needs a plan.

This technique is part of the Second Brain concept. For the full breakdown of the business/, plans/, ai-clone/ folders, see the guide to the Second Brain.

How to spot in advance where Claude will fail: self-critique with 10 reasons#

Here's the prompt framework I use verbatim:

Imagine the idea folder has been put through a methodology where you already think as if the project has completely failed. Name 10 reasons why, a year from now, I will have spent a lot of time and the idea will have turned out to be a failure. Your task is not to spare my feelings, but to be as harsh as possible.

After the 10 reasons - a second round: defend each reason against my counterarguments. Where am I weakest?

Third round: write a plan for what to do so that these problems don't occur.

I run it at three stages:

1. The first idea “everything is great” - when I'm sure. Self-critique cuts the idea down by 30-50%.
2. Midway through the plan - when I'm already deep into the work and have become blind.
3. Before launch - a final filter.

Claude really does challenge you in adversarial mode. GPT-5 in the same situation first praises the idea, then “tries to find improvements.” I noticed this difference after a year of experimenting:

The difference in adversarial mode looks like this for me: ChatGPT says, “Good catch, that's absolutely right.” Claude says in the same situation, “Agreed, that's complete crap; I'll redo it now.” When I need criticism, the second response saves me days of wasted work.

When not to apply it: positive iterations on UI and copywriting. Adversarial mode is out of place there - it will kill creativity.

This technique is known as a project premortem. I adapted it for working with an AI agent: instead of a team of people, you do a pre-mortem with Claude. No one is afraid to say “boss, the project will fail” - and blind spots surface in minutes.

How to do 5 sources of research in the time it takes to do one: parallel subagents#

Here's the prompt framework:

You already have the full context. Find and conduct deep research; launch 5 parallel subagents.

Subagent 1: go through professional networks - who is solving this problem?
Subagent 2: open-source solutions on GitHub - what is popular?
Subagent 3: startup accelerators - who is attracting
            investment in this niche?
Subagent 4: direct competitors' websites - what do they promise and
            at what price?
Subagent 5: comparisons and reviews - what do
            users say in reviews?

When everyone returns, launch a synthesis agent
that cross-references the 5 reports and produces an outline
for my second-brain folder.

What changes compared with ordinary research:

• Time: 5 simultaneous streams instead of 5 sequential ones. An hour of work in 15 minutes.
• Depth: each agent specializes. One agent's confirmation bias won't infect the others.
• Context: each subagent has its own context, separate from your main context.

For the full guide to subagents, see “Claude Code Subagents in 2026”. It also explains the difference between Skills and MCP - which to use when.

When not to apply it: cosmetic edits, bug fixes, small technical tasks. Research is overkill for anything smaller than “a new feature that takes 1+ day of work.”

How to give Claude tasks from your phone: a Telegram bot in your pocket#

How to set it up (4 steps):

1. A computer with continuous uptime - I disable sleep in the system settings (macOS: Energy Saver → Prevent computer from sleeping).
2. Claude Code running in a terminal, attached to the project folder.
3. The official Telegram plugin - add the marketplace with /plugin marketplace add anthropics/claude-plugins-official, then install /plugin install telegram@claude-plugins-official (the exact steps are updated over time - the latest instructions are in the official plugin repo).
4. The bot is tied to one session - this is currently a limitation: one bot = one project = one session. If you need a second one, set up a second bot.

What I do with the bot every day:

• I'm out for a walk and get an idea - I send it to the bot right away so I don't forget. The bot adds it to inbox.md for processing later.
• A call with a potential client - after the call, I ask the bot: “based on the transcript of the last call, name the 3 main pain points that work in our favor.” A minute later, I have a full analysis in the chat.
• At a café in the morning - “show me the open homework from my list.” No need to open the laptop.

⚠️ A catch: for now, you can't run /clear or /compact from the bot - the bot session is the same as the terminal session, and the context keeps growing. Restarting is only possible manually through the terminal.

For me, this is the most useful Claude Code extension of the past two weeks. It took me from “I work with Claude when I'm sitting at my desk” to “I work with Claude whenever I have a thought.”

What should you put to work first: a 7-day roadmap#

The combination of techniques matters more than any one of them on its own. Shift+Tab without Esc Esc makes experimentation scary. /compact without /cost means you don't know when to compress. Plans in files without parallel windows are a complication without a payoff.

To continue working with models, you can go to Ailoot.