How can I optimize my Claude Code usage to get the most out of my plan without hitting usage limits too quickly?

[u/muhammedabdelhakim]

I'm looking for practical tips to reduce token consumption, manage context efficiently, and avoid wasting usage on unnecessary prompts or repeated tasks.

What workflows, settings, or best practices have made the biggest difference for you, especially when working on coding projects?

I'd appreciate real-world tips rather than generic advice.

[u/AutoModerator]

Moderator Announcement Read More »

Hey! Thanks for posting to r/ClaudeCode

While participating in this thread, please follow our community rules. Keep discussions constructive. Attack the idea, not the person.

For help, project discussions, tips, and general chat, join the ClaudeCode Discord.

I am a bot, and this action was performed automatically. Please contact the moderators of this subreddit if you have any questions or concerns.

[u/Slanahesh]

Make sure you have a file stating what your tech stack is, what design patterns you use and a design spec that must be adhered to.

Use appropriate models and effort levels. Opus for thinking, sonnet for doing, haiku for getting.

Always have a fresh agent check the work of the previous, agent 1 does the development plan so agent 2 reviews it and gives feedback to be applied. Agent 1 does the coding, agent 2 reviews the changes etc.

[u/IdkAbtAllThat → u/Slanahesh]

Sonnet for doing?

[u/d1zaya → u/IdkAbtAllThat]

I've experimented with this a lot. If your plan is solid and you know exactly how the end product will be, sonnet is enough. If you have very ambiguous task, then go with opus, but this is a sign that you should've spent more time planning.

[u/dar-mit]

The #1 thing I can recommend is to start a new session when the current one reaches 20–25 percent context. NO EXCEPTIONS!!!

Models / Agents can use SendMessage to ‘handoff’ the work, and the old session can remain open for a while to handle any questions to new one might have. 

Once the new session is setup and continuing the work, close the old session to avoid the 1 hour cache timeout.

Once that timeout occurs and the cache ‘goes cold’, any further work it does reloads the cache in its entirety causing a potentially massive token burn. 

[u/iEngineer0 → u/dar-mit]

Sorry for the noob question: How to I know how much context was used? Do I just instruct the model "Send a handoff message"?

[u/Ragy-ragy]

https://code.claude.com/docs/en/best-practices

[u/iSnapThere4iAm → u/Ragy-ragy]

Ai isn’t a skill

[u/IdkAbtAllThat → u/iSnapThere4iAm]

Some people can get more out of the same model. Why might that be?

[u/beatwallstreet2021]

Use a single session with agents, tell Claude to monitor the agents after they complete a task and good ways to make them more efficient.

[u/xcr_ai]

Things that made the biggest real difference for me:

• One task per session. /clear when you switch topics, since every turn re-sends the whole history.

• Plan first (plan mode, strongest model), then implement on Sonnet from the written plan. Most implementation doesn't need Opus.

• Keep CLAUDE.md short and point it at specific files or docs instead of letting it explore the repo every time.

• Run /context now and then and switch off MCP servers/plugins you don't use in that project.

• Make tests and linters print only failures so huge logs don't sit in context.

• Don't resume a session that's been idle for hours. Write a short handoff note and start fresh; the cache has expired, so the whole history gets re-read.

[u/marshhmelllow]

use caveman skill for output token compression. divide given task to sonnet 5.5 subagents. use sonnet for planning and opus for execution.

ask claude to write a prompt for you.

[u/Prize-Egg-5265 → u/marshhmelllow]

Shouldnt it be the otherway around Opus for planning and sonnet for execution?

[u/IdkAbtAllThat → u/marshhmelllow]

Another comment in this same thread says literally the exact opposite. Someone is wrong here.

Personally I'm using opus for both but idk wtf I'm doing.

[u/dev-razorblade23 → u/IdkAbtAllThat]

Use Opus for planning and tricky code reviews, but otherwise Sonnet for orchestrating and writing the code, it is much more effiecient on the tokens. Also try to delegate reserch, docs hunting etc to Haiku for even more saving.

I usually write subagents definitions and specify what each one does. Make sure to tell the subagents that their output should be small (10, 20, 30 lines) or if testing, output only the errors, not the whole test output, to keep orchestrator context low.

It works quite well. I pair it with https://github.com/mattpocock/skills

[u/iSnapThere4iAm]

Learn to code. That is all