Claude Code: Non-Obvious Tips After Six Months of Daily Use

I use Claude Code every day — for personal projects and at my day job. Over this time, I've hit plenty of walls: lost context mid-task, got hallucinations out of nowhere, burned through limits too early. Gradually, I developed a set of habits that significantly improved my workflow. Here's what I learned.

Watch Your Context — It's the Most Important Thing

You might think that with context windows reaching a million tokens, this problem would solve itself. In practice, it's the opposite — it only gets worse. A longer context means more junk can accumulate in it, leading to more hallucinations and higher token consumption. So with a million tokens, you need to watch your context even more carefully than before.

Claude Code works within a context window. The more junk accumulates in it, the worse the output quality: the model gets confused, hallucinates, forgets things you discussed a minute ago. And you hit your limits faster — because every message resends the entire accumulated context.

Here's what helps keep context clean:

Monitor your context usage. Claude Code has a built-in command that shows how much context is used. Make it a habit to check — especially during long sessions.

Use /clear when switching tasks. Better yet, build a routine:

Don't drag bug discussion history into a new component's markup. Clean context = fresh perspective from the model.

MCP servers consume context. This used to be a serious problem — every connected MCP server would dump all its tool descriptions into the context at startup. It's better now: tools load lazily, only when needed. But if during a long session you've called several MCP servers — they're all sitting in the context taking up space. Keep this in mind.

Use /rewind when things go wrong. Claude Code spent a bunch of steps and ended up nowhere? Don't continue — roll back with /rewind. Add the clarifications that were missing to your prompt and restart. It's cheaper than trying to fix a bad result.

Offload Side Tasks from Your Main Session

During development, side tasks constantly pop up: commit, deploy, check something on the server, look up documentation. If you do everything in one session — context bloats, and by the end of your main task the model can barely function.

Create subagents for routine work. Commits, deploys, pushes — all of this can be delegated to separate agents. I have a /commit agent, for example, that analyzes the diff, writes a meaningful commit message, and commits — all in an isolated context. The main session doesn't even notice.

Use separate sessions for "side quests." If you need to figure something out mid-work that's not directly related to your current task — open a second Claude Code session. Investigate there, return to the main one with a ready answer.

Ctrl+S — when you remember something mid-prompt. You're typing a prompt and suddenly realize: "oh wait, I also need to fix that other thing." Don't erase it — press Ctrl+S to save your current prompt, handle the side task, then restore and continue.

Use /rename for Sessions

Simple but useful. By default, sessions are named after the first message — and within an hour they all turn into a mess of "fix the bug" and "add feature." Rename your sessions: /rename OAuth authorization — and you'll easily find what you need later.

Ask Claude to Ask Questions

One of the best techniques — at the start of a task, write: "Ask me at least three questions to make sure we understand the task the same way." Claude will stop, think, and ask about things you wouldn't have considered: edge cases, ambiguities in requirements, dependencies on other parts of the system. This saves tons of rework time.

Use Planning Mode

For non-trivial tasks, don't jump straight into code. Enable planning mode (/plan) — Claude will first create a plan, you'll discuss and adjust it, and only then will implementation begin. Without this, the model often starts with the first solution that comes to mind, and then you have to redo everything.

To-Do Lists for Complex Tasks

Claude Code can maintain task lists within a session. For multi-step tasks, this is a lifesaver — the model tracks what's done, what's remaining, and doesn't lose the thread. Ask: "Break the task into steps and maintain a to-do list" — and work becomes noticeably more organized.

Document Your Subtasks

If you're doing something large-scale within a project — don't keep it all in your head and don't rely on session context. Create a dedicated folder and use .md files for documentation.

Start with preliminary analysis: have Claude study the task and create a subtask list in an .md file. Then take the first subtask, detail it in a separate .md file — and implement it. Then the next one. During the work, you'll inevitably start new sessions — there will be many, context will be lost, details will be forgotten.

But if documentation lives in files — everything stays in place. At any point you can open the folder, see what's done, what's left, what decisions were made, and pick up right where you left off. This is especially useful when you come back to a task after a few days.

Organize Multi-Level Context

This is probably the most powerful technique, but it requires some setup effort. The idea is to layer your instructions for Claude:

Global CLAUDE.md — lives in your home directory. This is where you put rules that always apply to all projects: your OS, your shell, which commands to avoid, how you prefer to commit. This file is loaded into every session automatically.

Project CLAUDE.md — lives in each project's root. This describes everything about a specific project: how to build, how to deploy, architectural specifics, conventions. Claude reads it when launched in the project directory and immediately understands the context without extra explanations.

Skills — reusable instructions for common tasks. Think of them as prompt templates, but smarter: they load only when needed and can contain complex logic. For example, I have a skill for deployment, a skill for writing blog posts, a skill for working with a specific project.

Local instructions within a project — for large projects, you can place additional CLAUDE.md files in subdirectories. Working on the auth module — Claude will automatically pick up instructions from auth/CLAUDE.md.

Why bother with all this? So you don't explain the same things every time. Describe it once — it works in every session, on every device. It also saves context: instead of dictating how the project works each time, Claude just reads the file.

Bottom Line

Claude Code is a powerful tool, but without discipline it quickly becomes an expensive autocomplete. Watch your context, offload side tasks, use planning, and organize your instructions in layers — and you'll feel the difference. And if you get a little creative, you can do truly unexpected things with it — like building yourself an AI assistant in Telegram. And for how to organize your project so Claude Code works at full capacity — see the next post.