Most Claude Code users only ever type a prompt and hit enter. But Claude Code in 2026 ships with plan mode, checkpoint-based /rewind, reusable Skills, subagents, lifecycle hooks, /loop and /schedule automation, git-worktree parallelism, an /effort reasoning-depth dial, and cross-session auto-memory — and almost none of it is on by default. Turning even three or four of these on is what separates a slow back-and-forth chat from an agent that finishes real tickets while you do something else.
Why These Features Stay Hidden
Claude Code's default experience is deliberately minimal: type a request, watch it work, approve tool calls. That's fine for small edits, but it hides a second layer of the tool — slash commands, keyboard shortcuts, and config files under .claude/ — that most people never open. Anthropic's own Claude Code power-user tips and interactive mode reference document all of it, but it's spread across dozens of pages. Below are the 10 that make the biggest difference to coding speed, grouped by what problem each one actually solves.
The 10 Features, at a Glance
| Feature | What It Solves | How to Trigger It |
|---|---|---|
| Plan Mode | Claude edits the wrong thing before you've explained the whole task | Shift+Tab to cycle in |
/rewind checkpoints | An edit goes badly and you want to undo just Claude's changes | /rewind or double-tap Esc on an empty prompt |
| Skills | You re-explain the same multi-step workflow every session | .claude/skills/<name>/SKILL.md |
| Subagents | One long task pollutes your whole context window | .claude/agents/ + the Agent tool |
| Hooks | You want deterministic checks, not "please remember to run tests" | PreToolUse, PostToolUse, SessionStart, Stop |
/loop | A task needs repeated local passes (fix, test, repeat) | /loop <interval> <command> |
/schedule | The job needs to keep running after you close your laptop | /schedule (cloud-hosted, persists offline) |
| Git worktrees | Two features need to be built at once without branch conflicts | claude --worktree, /batch |
/effort | Simple edits burn the same reasoning budget as hard ones | /effort low|medium|high|xhigh|max|auto |
| Auto-memory | You repeat the same preferences and corrections every new session | ~/.claude/projects/<project>/memory/ |
1. Plan Mode: Make Claude Explain Before It Edits
Press Shift+Tab to cycle into plan mode before you approve any execution. Claude reads the codebase, proposes a step-by-step approach, and waits for your sign-off instead of touching files immediately. Anthropic's own guidance is blunt about the payoff: time spent in plan mode improves execution-stage performance, because Claude has already resolved ambiguity before the first edit lands. For any task bigger than a one-line fix, this alone cuts down the "undo and re-explain" loop that eats the most time.
2. /rewind and Checkpoints: A Real Undo Button
Claude Code automatically checkpoints your project before every prompt and before every edit. Type /rewind, or press Esc twice on an empty prompt line, to open a list of prior checkpoints tied to the exact message or tool call that triggered them. You can restore file changes only, conversation context only, or both together. It's worth knowing the scope: checkpointing only tracks changes made through Claude's own Write, Edit, and NotebookEdit tools, not bash commands or other side effects, and checkpoints are cleaned up on a rolling basis (roughly 30 days by default). It's a safety net for Claude's own edits, not a full system snapshot.
3. Skills: Package a Workflow Once, Reuse It Forever
A Skill is a folder-based instruction pack — a SKILL.md file under .claude/skills/<name>/ — that turns a general-purpose Claude Code session into a specialist for one specific workflow, invocable as a slash command. Instead of re-typing "research this topic, check our label taxonomy, write the FAQ section, then publish" every time, you write it once as a Skill and call it with /your-skill-name. This post itself was generated by exactly that pattern.
4. Subagents: Isolate Work Without Polluting Your Context
Subagents are separate Claude Code instances the main session can spawn, each with its own context window, its own tool permissions, and often its own model. The lead session only ever sees the subagent's final summary, not its intermediate exploration, which keeps a long research or refactor task from filling up your main conversation with noise. Define them under .claude/agents/, or launch a whole session with a custom one via --agent=<name>.
5. Hooks: Deterministic Automation Instead of Hoping Claude Remembers
Hooks fire shell commands at fixed points in Claude Code's lifecycle: SessionStart to load fresh context every time you launch a session, PreToolUse to log or block specific bash commands before they run, PostToolUse to auto-run a formatter after every edit, and Stop to run a deterministic check (like a test suite) before a long task is allowed to end. Because hooks are enforced by the harness rather than by the model choosing to comply, they're the right tool for anything that must happen every single time — formatting, linting, or a safety check — not something you'd want to rely on a prompt reminder for.
6. /loop: Recurring Local Passes Without Babysitting
Running /loop <interval> <command> puts Claude into a repeating local cycle — for example, running a test suite and refactoring code every few minutes until the result is fully green, or checking a PR for new review comments on a fixed cadence. It's built for bounded, local automation: a session started with /loop keeps running on your machine for as long as you leave it up, rather than needing you to re-trigger each pass by hand.
7. /schedule: The Cloud Version, for When Your Laptop Is Closed
Where /loop runs locally and stops when your machine does, /schedule creates cloud-hosted jobs on a cron-style schedule that keep running even when your device is offline. Use /loop for a tight, session-bound automation you're actively watching; use /schedule for a recurring job — a daily dependency check, a weekly report — that needs to survive you closing the lid.
8. Git Worktrees: True Parallel Sessions on One Repo
Running claude --worktree isolates a session in its own git worktree, so you can run several Claude Code instances against the same repository at the same time without them stepping on each other's uncommitted changes. Pair it with --tmux to launch each worktree session in its own terminal pane, or use /batch to distribute a large migration across multiple parallel agents automatically, each in its own isolated worktree.
9. /effort: Stop Paying Max Reasoning Cost for Small Edits
The /effort command sets how much reasoning depth Claude applies, from low through medium, high, xhigh, and max, or leaves it on auto. A one-line config change doesn't need the same reasoning budget as debugging a race condition across three services. Dropping effort for routine edits speeds up response time noticeably; raising it for genuinely hard problems is often the actual fix when Claude keeps missing an edge case, not a longer prompt.
10. Auto-Memory: Preferences That Survive Between Sessions
Claude Code can persist what it learns about how you like to work — corrections, conventions, recurring project context — to files under ~/.claude/projects/<project>/memory/, configurable through /memory. Combined with a CLAUDE.md file at the project root (the standard advice: whenever Claude does something wrong, add the correction to CLAUDE.md so it doesn't happen again), this closes the loop where every new session starts from zero context about your preferences.
Bonus: Smaller Switches Worth Knowing
A few more are worth a one-line mention even though they didn't make the top 10: /output-style changes Claude's tone and response format (Concise, Explanatory, Learning, or a custom style you define with /output-style:new) without changing what it knows or can do; /statusline generates a custom status line showing model, running cost, and context usage; and /permissions lets you pre-approve safe, repeated commands (including wildcards like "Bash(bun run *)") so you stop getting asked the same yes/no question every session.
FAQ
How do I turn on Claude Code plan mode?
Press Shift+Tab to cycle into plan mode, or explicitly ask Claude Code to plan out its approach before making any changes. Claude will read the relevant code and propose a step-by-step plan, and won't start editing files until you approve it.
What's the difference between /rewind and git revert?
/rewind only restores changes made through Claude Code's own Write, Edit, and NotebookEdit tools, using automatic checkpoints created before every prompt and edit — it won't undo bash commands or other side effects. git revert operates on committed git history regardless of who or what made the change. Use /rewind to quickly back out of an in-progress Claude edit; use git for anything already committed.
What's the difference between a Skill and a subagent in Claude Code?
A Skill is a reusable instruction pack (a SKILL.md file) that runs inside your current session and turns it into a specialist for one workflow, invoked as a slash command. A subagent is a separate Claude Code instance with its own context window and tool permissions, spawned by the main session to do isolated work and report back only a summary. Skills change how the current session behaves; subagents create a new, isolated session.
Do Claude Code hooks require me to approve each run?
No. Hooks are enforced by the Claude Code harness itself at fixed lifecycle points (SessionStart, PreToolUse, PostToolUse, Stop, and others), so they run automatically as shell commands without needing per-run approval from Claude. That's the point — they exist for checks that must be deterministic rather than dependent on the model remembering to do them.
What's the difference between /loop and /schedule?
/loop <interval> <command> runs a recurring automation locally, bound to your current session and machine — it stops if you close the session. /schedule creates a cloud-hosted, cron-style job that keeps running even when your device is offline, which makes it the right choice for anything that needs to survive past when you'd normally shut your laptop.
Can I run multiple Claude Code sessions on the same repo at once?
Yes, using claude --worktree, which isolates each session in its own git worktree so parallel sessions don't collide on uncommitted changes. --worktree --tmux puts each one in its own terminal pane, and /batch can spread a single large migration across several worktree-isolated agents automatically.
Does Claude Code remember my preferences across different sessions?
Yes, through two complementary mechanisms: a project's CLAUDE.md file for explicit, team-shared rules, and auto-memory files under ~/.claude/projects/<project>/memory/ (configurable via /memory) for preferences and corrections Claude picks up over time. Together they mean a new session doesn't start from zero context about how you like to work.
Does using /effort actually change how good the code is?
It changes how much reasoning budget Claude spends before answering, not what it fundamentally knows. Lower effort levels respond faster and are appropriate for small, well-defined edits; raising effort to high, xhigh, or max gives Claude more room to reason through genuinely hard problems, such as concurrency bugs or multi-service debugging, where a fast-but-shallow pass tends to miss the actual cause.
Further reading:
- How to Make Claude Code Faster and Choose the Right Model for Software Development (2026 Guide)
- AGENTS.md vs CLAUDE.md: What's the Real Difference, and Do You Need Both? (2026)
- CodeGraph and the Best Code Indexing Tools for Faster, More Efficient AI-Assisted Development (2026)
- AI Coding Agents FAQ: Claude Code, Cursor, Copilot, and Codex Explained (2026)