I cut my Claude token use in half by moving instructions out of the main session

Published Oct 29, 2026, 7:30 AM EDT Dhruv Bhutani has been writing about consumer technology since 2008, offering deep insights into the personal technology landscape through features and opinion pieces. He writes for XDA-Developers, where he focuses on topics like productivity, networking, self-hosting, and more. Over the years, his work has also appeared in leading publications such as Android Police, Android Authority, CNET, PCMag, and more. Outside of his professional work, Dhruv is an avid fan of horror media spanning films and literature, enjoys fitness activities, collects vinyl records, and plays the guitar. I use Claude all the time for troubleshooting my self-hosting setup. It's been an incredible tool for everything from reviewing Docker logs to building small apps and dashboards, but letting it loose on a project can just as easily burn through my tokens and usage allowance. It turns out the complexity of the task isn't always what burns through AI tokens. The way the LLM works, exploring files or loading instructions can also dictate your token burn rate. I've been exploring ways to reduce my AI token use, and I discovered that getting more out of Claude isn't just about better prompting; it's also about changing how I organize projects and delegate work to the LLM. In fact, Anthropic offers several features that address these problems directly. Moving instructions out of Claude's always-loaded context and using subagents to isolate tasks have helped me most in reducing my Claude token use. Keep your CLAUDE.md file lean to avoid unnecessary context Separate instruction files and skills for project-specific tasks Anytime I work on a project in Claude Code, I need it to understand the directory structure, know how to run the application, and follow my specific instructions. The obvious solution is to put everything into a CLAUDE.md file at the root of the project. The problem is that this file loads at the start of nearly every session, and Claude carries the full context with it, even when it's not relevant to the session. A better approach is to treat your md file as a project guide rather than a repo for every instruction you might need. Instead, you can create a subset of instruction files and use CLAUDE.md to guide the LLM to individual contextually relevant files. For me, this approach has been useful for projects involving Docker and self-hosted applications. A typical project includes everything from Compose files to app configurations, scripts, and documentation. There's simply no need for Claude to load up all this information when the ask is about a configuration change. My root CLAUDE.md contains the essentials, including what the project does, where its main files live, which commands I use to run tests, and any important restrictions. Detailed instructions for individual components can live closer to the relevant files. For example, if a project has separate frontend and backend directories, I can create a CLAUDE.md file in each directory. Claude Code can load the relevant instructions when it works with files in that part of the project, rather than keeping every specialist instruction in its initial context. I can also use skills for workflows that get repeated often enough. For example, I use Claude regularly to investigate Docker-related issues when I'm trying to get a service up and running. Using a skill lets me define a workflow that tells it where my config files are, which commands to run, and how to report the results. Claude can load this procedure on demand instead of including it in my project instructions. I use subagents to avoid bloating up my main session Delegate lengthy troubleshooting tasks to subagents Subagents are the secret to saving a bunch on token costs. For example, when a Docker container refuses to start, I might need to inspect its logs, check the Compose configuration, and verify volume permissions. Each of these adds more information to the main conversation. If Claude reads several large log files and explores unrelated configuration files, that information adds to the token cost. Claude Code's subagents offer a way to segregate these tasks. A subagent operates in its own context window and can investigate a specific problem before returning its findings to the main session. I find this particularly useful when a task has distinct steps. Here's an example. If a self-hosted app that I'm running reports database errors, instead of sharing the full context of the installation, what I'm doing with the app, and the database logs, I can just use a subagent to investigate the database startup errors, inspect relevant logs, and identify the most likely cause of the error. I can then return a concise summary with the evidence alongside. This keeps the investigation focused and prevents the main session from needing the full context. It's worth keeping in mind that subagents aren't a one-stop-shop solution. You need to make a conscious call on whether a subagent is the right approach. Subagents use their own resources, and their work can increase total token usage even as it reduces the context the main session carries. They make the most sense when an investigation is substantial, has a clearly defined objective, and can return a short, useful result. Essentially, keep the straightforward changes in the main session and delegate specific fixes to subagents. Reduce unnecessary work, not just tokens Reducing token usage is a balancing act, and even these tricks don't always work. However, avoiding unnecessary context or work before the LLM reaches a useful result certainly helps. Add subagents for lengthy research, and you can gain more control over context and avoid spending resources that don't necessarily add to your project. Claude is an AI assistant and LLM developed by Anthropic.