21 Claude Code Tips and Shortcuts to Cut Tokens and Speed Up Work
Claude Code shortcuts, skills, and settings that trim verbose output, manage sessions, and reduce token costs for daily coding workflows.
What are the most useful Claude Code tips for daily work?
Claude Code has grown well past a chat window bolted onto a terminal. Between built-in keyboard shortcuts, a concise output style shipped directly into the tool, and a growing ecosystem of installable skills, there’s now a real toolkit for cutting token spend, recovering from broken sessions, and getting answers without wading through commentary. Most of these features aren’t new models or paid upgrades. They’re settings and habits that are already available and mostly ignored.
TL;DR
- Skills that trim verbosity, like a plain-English writing skill or the “Caveman” skill, can shrink responses from dozens of tokens down to a fraction of that while keeping the meaning intact.
- The built-in concise output style, turned on through
/configthenoutput style, makes Claude lead with results and drop running commentary while still keeping error details. - Session search shortcuts like Control+R (search current session prompts) and Control+S (widen search to the whole project or machine) let you find a prompt you wrote weeks ago without scrolling back through history.
- Rewind beats compact when an output breaks: rewinding to a prior point preserves context, while clearing or compacting a broken session loses it, and rewind can’t restore files deleted through bash commands, so Git is still needed for that.
- Renaming sessions and using the
@symbol to point at specific files makes it far easier to resume the right conversation or make sure Claude edits the exact file you mean. - Token-saving habits, like appending “give me a quick answer” instead of switching models mid-session, avoid rebuilding the cache and keep costs down.
- Usage-tracking tools like the CC usage repository read local Claude Code logs (and logs from tools like Codex, Gemini, Goose, and Open Code) to show exactly what you’re spending across models and time periods.
One coffee. One working app.
You bring the idea. Remy manages the project.
How do skills reduce verbose Claude output?
Claude Code responses can default to long, over-explained answers, which costs both reading time and output tokens. A few community skills address this directly.
One approach uses a plain-English style skill modeled on the kind of writing found in technical manuals designed for tired readers who can’t afford to misinterpret an instruction: short, direct, no padding. Installing it changes Claude’s default response style from paragraphs of explanation to something closer to a checklist.
A second option, called Stop Slop, focuses on editing rather than generation. You feed it a draft and it strips out common “AI tells,” the stylistic tics that make writing sound machine-generated. It works by scoring text across a handful of dimensions (rhythm, trust, authenticity, density) out of a total of 50 points, and revises anything that scores below a threshold. It’s built to work with core rules rather than long lists of examples, which keeps the skill itself short and easy to adapt.
The most aggressive option is a skill nicknamed Caveman, which strips language down to the fewest words needed to preserve meaning. In practice, this can take a normal multi-sentence agent response and reduce it to a fraction of the length, cutting output tokens directly and making responses faster to scan.
Is there a built-in way to get concise output without installing anything?
Yes. Claude Code shipped a native concise output style that does a dialed-down version of what the verbosity-reduction skills do. It’s turned on through the /config command, then selecting output style and choosing concise. Once enabled, Claude leads with results instead of narrating what it’s about to do, and drops the incidental commentary between steps. Critically, it doesn’t strip details that matter: errors, warnings, and required information stay intact. This is the lowest-effort way to reduce clutter in daily use, since it requires no external install and takes effect immediately.
What keyboard shortcuts actually save time in the terminal?
A cluster of shortcuts change how you navigate sessions and prompts:
- Control+R opens a search across prompts in the current session, functioning like a find command for everything you’ve asked Claude so far.
- Control+S, pressed once, widens that search to every session in the current project. Pressed again, it widens further to every project on the machine, meaning a prompt written weeks ago in an unrelated repository can be pulled up with a few keywords.
- Control+T opens a breakdown of active subtasks and teammates when Claude is running a fanned-out research or multi-step job, similar to the task list view in Claude’s desktop app. The same information is available by running
/tasks. - Control+G brings your most recent prompt and Claude’s last response into an editable window, so you can write a new prompt directly underneath the previous exchange instead of scrolling through a collapsed output. Getting the last response to show up requires enabling “show last response in external editor” via
/config. - Option+T toggles extended thinking mode on or off for a given prompt, useful when a task doesn’t need deep reasoning.
- Control+O expands every collapsed tool call and sub-task into one continuous, readable log, giving full visibility into what happened during a complex run.
- Control+B backgrounds a currently running task, sending its output to a file Claude can read later, freeing up the same terminal window to keep working instead of opening a second terminal.
Remy doesn't write the code. It manages the agents who do.
Remy runs the project. The specialists do the work. You work with the PM, not the implementers.
For the opposite of Control+O, running /focus strips everything down to just the prompts, a short summary, and the direct response, cutting out logs entirely.
How do you recover from a broken output without losing context?
The instinct when a session goes wrong, or when the context window fills up, is often to clear it and start fresh. That’s usually the wrong move, because clearing discards the context entirely. The better option is the rewind function, which jumps back to an earlier point in the same session while keeping that prior context intact and accessible. If a generated file or webpage comes out broken, rewind to the point before it broke and try again, rather than asking Claude to patch the mistake forward.
Rewind has one real limitation: it doesn’t track changes made through bash. If a file was deleted as part of cleanup, rewinding the session won’t bring it back. That still requires Git.
How do you manage sessions across projects and machines?
Claude Code’s resume function lists prior sessions in the current repository, but Control+A widens that list to every session across every repository on the machine, and Control+W does the same for work trees. Renaming sessions with the rename command turns cryptic session IDs into readable labels, which makes finding the right one later much faster.
Pointing at specific files with the @ symbol removes ambiguity when giving instructions, especially when running parallel sessions (a front-end session and a back-end session, for example) where the wrong file could easily get edited.
The --teleport flag pulls a session started in Claude’s web app into the local Claude Code terminal, syncing work between the cloud version and the desktop tool.
How do you cut Claude Code costs without switching models?
Switching from a large model like Opus to a smaller one such as Sonnet mid-session feels like an obvious cost-saver, but it rebuilds the entire cache, which means recaching every prior token, an expensive operation if the session is long. A cheaper fix is appending a phrase like “give me a quick answer” to a prompt. This signals Claude to skip deep reasoning for that single turn without switching models or touching the cache.
Claude Code also intervenes automatically on old, token-heavy sessions: once a session passes roughly an hour old and around 100,000 tokens, it offers to resume from a summary instead of rereading the full uncached conversation history, which would otherwise be the most expensive kind of request possible.
For visibility into actual spend, the CC usage repository reads local logs, not just from Claude Code but from other coding assistants too, and breaks down models used, input and output tokens, and total cost by date. Running /recap inside a session also generates a one-line summary of what the session’s goal was and suggests next steps, useful for picking back up after time away.
Frequently Asked Questions
What is the concise output style in Claude Code?
It’s a built-in setting, enabled through /config then output style, that makes Claude answer with results first and drop routine commentary, while still preserving full detail on errors and warnings.
Plans first. Then code.
Remy writes the spec, manages the build, and ships the app.
Does rewind delete my files if I use it after deleting something?
No, but it also won’t restore deleted files. Rewind only tracks conversation and session state, not changes made outside the model through bash commands, so file deletions still require Git to undo.
How do I search my old Claude Code prompts?
Control+R searches prompts within the current session. Pressing Control+S widens the search to the whole current project, and pressing it again widens it to every project on the machine.
Can I reduce token costs without changing models?
Yes. Adding a phrase like “give me a quick answer” tells Claude to skip deep reasoning for that turn without switching models, which avoids rebuilding and recaching the session’s context.
What does the CC usage tool actually track?
It reads local logs from Claude Code and other tools like Codex, Gemini, Goose, and Open Code, then reports the models used, token counts, and cost breakdowns across chosen time periods.
