Getting a result out of Claude Code is easy. Getting the right result, verified, without paying for it twice, takes a handful of habits. This is how to use Claude Code effectively, written from the operating rules we actually run on.
- Tell it what it cannot see. The file, the symptom, what done means, and anything decided outside the repository.
- Plan before large changes. Reading a plan costs minutes. Unpicking a wrong build costs the afternoon.
- Give it a check that can fail. A check that only ever returns green is worse than none, and we have shipped one.
- Verify from the live system. Green CI and a confident summary are not proof that the change is live.
- Parallel sessions need worktrees. One shared checkout cost us three collisions in a single day.
- Delegate for parallelism, not for quality. A subagent is the same model starting with less context.
- Ship through a pull request. A person approves whatever cannot be taken back.
Our evidence is first-hand. We keep a global instruction file at ~/.claude/CLAUDE.md that every session reads, and each rule in it exists because something went wrong once. Vendor facts below come from Anthropic's documentation as fetched on 18 November 2026. If you have not installed the tool yet, start with how to use Claude Code in terminal; the wider picture is in AI agents explained.
Start with what Claude cannot see
Anthropic's best-practices page opens with a useful reframe. Current models read a codebase quickly and well, so most of what you might explain, Claude will find. What it cannot find is whatever was never in the repository: a decision made in a meeting, a deploy process that lives in one person's head, the reason an ugly file must not be touched.
The docs give a two-question test before you write anything down for Claude: could it find this by reading the code, and would it actually go and look? If both are yes, leave it out.
That test shapes three things.
The prompt. The docs' own example: instead of "fix the login bug", write "users report login fails after the session times out. look at token refresh in src/auth/, write a failing test that reproduces it, then fix it". You have named the symptom, the place and the definition of fixed. If you already hold the evidence, hand it over: type @ and a path to include a file, paste a screenshot, or pipe output in from your shell.
The instruction file. CLAUDE.md loads into every session, so every line in it takes a little attention on every task. Keep it to the commands that verify work, the places where the code misleads, and decisions that are not in the repo. We go through a real one in CLAUDE.md best practices.
The conversation itself. Every request sends the whole conversation. A session that has collected three unrelated tasks re-reads all three on every turn of the fourth. So:
/clear
between unrelated tasks, and when a long task needs to keep going:
/compact keep the API changes and the test commands
/context shows what is filling the window. The docs note that with large context windows you will rarely run out, but you can still pay for context you do not need, and a focused conversation gives better answers.
One habit of ours belongs here. Our operating file says: "Do independent lookups in one batch, and prefer a single verification pass that checks everything at once over a trickle of small ones." Ask for five facts in one message and they are gathered together. Ask in five messages and you have five round trips, each carrying the full history.
Plan, then act
For anything that touches more than a couple of files, start in plan mode. Press Shift+Tab until the status bar says ⏸ plan mode on, or prefix one prompt:
/plan move the form handler to the new endpoint and keep the old route as a redirect
In plan mode, Claude researches and writes a plan without editing your source. When the plan is ready you choose between approving it, approving it and reviewing each edit yourself, or "No, keep planning" with a note on what to change. Ctrl+G opens the plan in your editor so you can change it directly.
When you do not yet know what you want, the docs suggest letting Claude interview you first:
I want to add rate limiting to the public API but haven't thought it through yet.
Interview me until you could write the spec, then write it to SPEC.md.
Then start a fresh session and build from SPEC.md. The build begins with a clean context and a written definition of done.
Planning is also the moment to ask for disagreement. An agent asked to support your idea will support it. Our global file has a section called "Evaluate critically" that changes the default:
- Lead with what is weak, risky, or likely to fail — especially when the user is invested in the approach.
- Recommend "don't build this" when that is the honest answer. A no-rebuild recommendation has been the right call before.
- Give one recommendation, not a survey of options. State the trade-off in a sentence and pick.
The memory note behind that rule records the instruction it came from: "Be critical and provide actual advice, not just a positive path for our ideas." A plan that has survived its own counter-argument is worth far more than one that was only ever agreed with.
Give it a check that can fail
The docs put this plainly: "Claude stops when the work looks done." If it has nothing to run that returns pass or fail, looking done is all it has, and you become the test suite.
A check can be a test file, a build's exit code, a linter, a script that compares output with a fixture, or a browser screenshot beside the mockup. The strictness is yours to choose:
- In the prompt: "run the auth tests after, and keep going until they pass."
- As a goal:
/goalsets a condition that is checked after every turn. - As a Stop hook: Claude Code itself refuses to end the turn until your script passes.
- By a fresh reviewer:
/code-reviewreviews the diff in a subagent that never saw the conversation.
The Stop hook version from Anthropic's docs is a few lines in .claude/settings.json:
{
"hooks": {
"Stop": [
{
"hooks": [
{ "type": "command", "command": "pnpm tsc --noEmit 1>&2 || exit 2" }
]
}
]
}
}
We cover that mechanism properly in our guide to Claude Code hooks.
Now the part the docs do not warn you about: checks lie. We keep a memory note on browser layout assertions that pass without testing anything, and every entry in it was a real green light on broken work. One example: on a client site whose theme hides horizontal overflow on both the root elements, our overflow check compared scroll width with client width and read 0. A footer was running 264 pixels off a phone screen at the time. Only the screenshot showed it. A check that counted laid-out elements crossing the viewport edge read 23 on the broken page and 0 on the fixed one.
The rule we took from it, quoted from the note:
An assertion that can only ever return the passing value is worse than no assertion, because it reads as coverage. When a layout check goes green first try, verify it can fail — break the CSS on purpose and confirm it reports.
Ask for evidence either way. The command and its output, or the screenshot. "All tests pass" tells you very little.
Verify from the live system, not from inference
This is the first section of our operating file, and the one we would keep if we could keep only one:
## Verify before you assert
Claims about live systems must come from the live system, not from inference, cached knowledge, or a memory file.
- CI and scheduled jobs: a successful manual dispatch is not proof the schedule works. Check the scheduled trigger specifically.
- URLs and pages you reference in ads, copy, or config must resolve 2xx/3xx. Check them; do not invent plausible paths.
- Anything CDN-fronted may be stale. Verify origin with a cache-buster before concluding the deploy didn't work — or that it did.
Each bullet is a past mistake. An agent reads the HTML, sees the tracking snippet and reports that the tag fires. It does not know that. A browser knows that. An agent runs a workflow by hand, sees it pass and reports the schedule is fixed. The schedule is a different trigger.
The same file is firm about what comes after a deploy: "Green CI is not proof the change is live. After a deploy, fetch the live artifact with a cache-buster and confirm both that the change landed and that nothing adjacent broke." And it gives the agent a way to be honest when it cannot check: label the claim "Verified" or "Confirm in account" instead of smoothing it into a confident sentence.
There is a limit worth copying too. The rule is about the world, not about the agent's own output. Our file says it does not mean re-reading its own answer or spawning a subagent to check its work, because that costs tokens without improving accuracy. Verification means going to the system. A second opinion from the same model on the same text is not that.
Parallel sessions need worktrees
Running several sessions at once is where the real speed is, and where we lost the most time learning.
On 20 August 2026 we had five sessions live against one repository, sharing one working tree. Our notes record three collisions that day. A git add -A swept another session's uncommitted files into a commit, which merged and deployed unreviewed. A git checkout moved HEAD while another session was mid-commit, so its work landed on local main. And a publish was blocked because HEAD was sitting on someone else's branch.
Two sessions in one checkout share HEAD, the index and the files. Habits that are safe alone are destructive there.
The fix is a git worktree: a separate working directory with its own files and branch, sharing the same history. Claude Code has this built in. From the worktrees documentation:
claude --worktree feature-auth
That creates a worktree under .claude/worktrees/feature-auth/ on a new branch named worktree-feature-auth and starts the session in it. Run it again with another name in another terminal for a second isolated session. The docs recommend adding .claude/worktrees/ to .gitignore.
A worktree is a fresh checkout, so gitignored files are missing. We hit this immediately: our blog worktree had no Python virtual environment, so its build script borrows the main checkout's interpreter. For small files, list them in a .worktreeinclude at the repository root and Claude Code copies them into each new worktree:
.env
.env.local
Worktrees do not remove every shared surface. They share one .git directory, and in some of our repositories sessions still share a checkout. The rules we keep regardless of how many sessions are running:
- Never
git add -Aorgit add .Stage explicit paths. - Commit with
git commit --only -- <paths>. A plain commit takes everything staged, including what another session staged a few seconds earlier. That happened to us, with five files. git statusbefore any checkout, and treat a file you did not create as someone else's. Stop and ask.- Cut branches from
origin/main, not from wherever HEAD happens to be. - Never delete a live
index.lock. It means another session's commit is running. Wait.
In one client repository we stopped relying on the written rule alone and added a hook: a small script that refuses any commit without explicit paths. Anthropic's docs draw the same line. A rule in a prompt is followed nearly every time, and if nearly is not good enough, it belongs in a hook.
When to delegate to subagents, and when not to
Claude Code delegates on its own. Broad searches go to a built-in Explore agent, and side tasks can be forked into the background. The subagents documentation explains the mechanics, and we go deeper in Claude Code subagents. The question for efficiency is when delegation pays.
Anthropic's answer, as of November 2026, is specific. Subagents pay off for independent work running in parallel, for keeping long output out of your main conversation, and for a reviewer that has not seen how the code was written. What they cost is tokens, because every subagent sends its own requests against the same usage, and sometimes time, because a fresh subagent must regather context your conversation already had. The docs add: "Handing the same task to a subagent doesn't make the answer any better."
Our own rule agrees, and it is stricter:
## Delegation
- Delegate only for large, genuinely independent, parallelizable work: a wide multi-file investigation, several unrelated tracks.
- Do not delegate what you could finish yourself in a handful of tool calls, and do not use a subagent to verify or double-check your own work.
- If one subagent can do it, use one. Keep spawn counts low, and brief each one precisely the first time.
- Once you delegate, commit to it. Don't redo the subagent's work or re-derive its findings.
The brief matters more than the count. A non-fork subagent starts with a fresh context window. It does not see your conversation. Whatever it needs has to be in the message that launches it.
Large fan-outs also meet the physical machine. On a side project, our laptop went to sleep during two background runs, and 18 of 36 image agents and 4 of 7 build agents failed with network errors. What that cost was time, not work, because the run had been written to resume: results on disk as they landed, and a first step in each agent that checked what already existed. Before a run of more than about half an hour we now keep the machine awake and say so. The same goes for where files live. Session scratch space under the system temp directory is not durable: we once found helper scripts gone after about three idle days. Anything you will run again belongs in the repository.
Ship through a pull request
The last habit is about who has the final word. Anthropic's best-practices table puts it in two columns: the non-deterministic version is "Claude's summary of what it did", and the deterministic version is "branch protection, a person who approves the merge".
Our shipping rule is short:
- Branch off main, commit, open a PR. Do not commit straight to main.
- Validate machine-readable files after scripted edits: `json.loads`, `yaml.safe_load`, `node --check`, `py_compile`.
- Keep unrelated stray files out of the change set.
Before the pull request opens, one more sweep. Our file calls it "Finish the change": a removal or rename is done when every surface is updated, not when the obvious one is. Sweep the whole repository for the identifier, including CI workflows, generated pages, docs and user-visible copy. The example in our file is a real one: a tracking tag removed from the template, the tracker and the disclosures, with a live "manage your preferences" link still pointing at the service nobody used any more.
The file also separates what the agent may do alone from what needs a person: spending money, merging anything that changes pricing or is customer-facing, pushing to production, deleting work it did not create. Approval for one action does not extend to the next.
Usage limits and token usage: what actually moves it
Plans come with usage limits, and they change, so we will not quote them. Anthropic's pricing page is the source. What you control is how fast you use them.
Start by measuring. /usage shows plan usage, and on paid plans the costs documentation says it attributes recent usage to skills, subagents, plugins and individual MCP servers, with recommendations for anything behind 10% or more of your usage.
The same page explains why a long session climbs: the full conversation is sent with every request, a first message after a long break misses the prompt cache and reprocesses everything, and scheduled loops and subagents keep sending requests while you are not typing. Its levers, roughly in the order they have mattered for us:
- Clear between tasks. Free, and the biggest single effect.
- Write specific prompts. "Improve this codebase" triggers a broad scan.
- Move long procedures out of
CLAUDE.mdinto skills, which load only when needed. See our guide to Claude skills. - Turn off MCP servers you are not using with
/mcp, and prefer a command-line tool where one exists. - Install a code intelligence plugin for typed languages. This is the documented answer to "plugins to reduce token usage": one go-to-definition call replaces a search plus several file reads.
- Use a smaller model for simple subagent work.
The habits, in one line. How to use Claude Code effectively comes down to a short loop: say what it cannot see, plan, give it a check that can genuinely fail, verify against the live system, and let a person approve the merge. The rest, worktrees, subagents and usage, is about doing that loop several times at once without the sessions tripping over each other.
We run client sites and our own scheduled SEO audit agent on these rules. If you want a team that already works this way, that is our AI integration service, and you can tell us what you're building.
Common questions
How to use Claude Code effectively?
Give it what it cannot see, then give it a way to check its own work. In practice: write a specific prompt that names the file, the symptom and what done looks like; plan before large changes; keep a short CLAUDE.md with the commands that verify work; clear the conversation between unrelated tasks; and ask for evidence, such as the command it ran and its output. Ship through a branch and a pull request so a person approves anything that cannot be taken back.
What are the best Claude Code workflow tips?
The ones that hold up for us are plain. Start each task in a fresh conversation. Use plan mode for anything touching more than a couple of files. Batch independent lookups into one request. Run parallel sessions in separate git worktrees, never in one shared checkout. Stage explicit file paths instead of everything. After a deploy, fetch the live page with a cache-buster and confirm the change landed. And when a new check passes first time, break the thing on purpose to prove the check can fail.
What are Claude Code best practices according to Anthropic?
As of November 2026, Anthropic's best-practices page centres on three ideas: tell Claude what it cannot see, give it a check to run, and enforce the rules that cannot have exceptions with hooks, deny rules or managed settings instead of prompt text. It also lists advice you can stop following, such as adding capital-letter emphasis, telling it to think harder, or describing your file layout in CLAUDE.md. We follow most of it and add stricter rules about verifying live systems.
Are there Claude Code plugins to reduce token usage?
Anthropic's cost documentation recommends code intelligence plugins for typed languages, because a single go-to-definition call can replace a search followed by reading several candidate files. Beyond plugins, the same page lists bigger levers: clearing between tasks, turning off MCP servers you are not using, moving long procedures out of CLAUDE.md into skills that load on demand, and choosing a smaller model for simple subagent work. Run /usage first to see where your usage is actually going before installing anything.
How do Claude Code usage limits work?
Subscription plans include usage with limits, and Console accounts are billed by tokens. Anthropic's pricing page has the current plans. Inside a session, /usage shows your plan usage and, on paid plans, a breakdown by skill, subagent, plugin and MCP server with recommendations. The documentation explains why long sessions climb: every request sends the whole conversation, subagents send their own requests, and scheduled loops keep firing while you are idle. Shorter, focused sessions use less than one all-day conversation.
When should I use subagents in Claude Code?
Use them for independent work that can run in parallel, for output too noisy to keep in your main conversation, and for a reviewer that has not seen how the code was written. Do not use them hoping for a better answer: Anthropic's docs say handing the same task to a subagent does not improve it, and a fresh subagent has to regather context you already had. Our own rule is to delegate only large, independent, parallel work, and never to double-check our own output.
How do I run multiple Claude Code sessions at the same time?
Give each session its own git worktree. The command claude --worktree with a name creates a separate working directory on its own branch and starts a session there, so two sessions cannot edit the same files or move each other's HEAD. List the gitignored files each worktree needs in a .worktreeinclude file. Worktrees still share one git directory, so commit explicit paths and expect to wait when another session holds the index lock.

