Using Claude Code effectively: what actually works in 2026

Most Claude Code tips are about hidden commands and magic prompts. Anthropic's own documentation puts the emphasis elsewhere. Give Claude a check that can pass or fail, keep the context focused, and don't let it do more than needed. This is the way of working that remains once you strip away the hype.

Updated on 5 November 2026. In September this article opened with "the context window is your main constraint". Anthropic itself now lists that as outdated advice: most current models have a one-million-token window. Also new: Opus 5.5 at medium effort as the default on most plans, ultrathink raising a turn to xhigh, and /goal, /verify and /code-review to check work.

What is Claude Code?

Claude Code is Anthropic's coding agent. Unlike a chatbot that answers and waits, it reads your files, runs commands, changes code and works through a problem step by step while you watch, steer or do something else. You can use it in the terminal, in editors such as VS Code, and in the desktop and web apps.

Everything Claude reads in a session counts towards the context window: your messages, every file it opens, every line of command output. Most current models have a one-million-token window, and Claude Code summarises the conversation itself when it gets close to full. Running out is therefore rare. Context does cost money: every request sends the whole conversation again. A session that has collected three unrelated tasks re-reads all three on every turn, and a focused context also gets better answers.

Start with /init and a short CLAUDE.md

/init looks at your project and generates a first CLAUDE.md: a file Claude reads at the start of every session. It should contain what Claude cannot work out from the code: build and test commands, style rules that differ from the defaults, architectural decisions, quirks of your development environment.

Keep it short. Anthropic aims for under two hundred lines per file: longer files use more context and are followed less consistently. Don't describe the layout of your repository; Claude reads that itself. Write down what isn't anywhere else.

Too thin, because Claude can read this from the code:

# Laravel project
Uses MySQL
Frontend uses React

More useful, because these are agreements that live nowhere else:

# Architecture
- Business logic in services, never direct queries in controllers
- API responses via DTOs

# Workflow
- Run `php artisan test --filter=Auth` after every authentication change
- Never change billing logic without tests

# Gotchas
- The local queue doesn't run; test jobs synchronously with QUEUE_CONNECTION=sync

Point to separate documents for details, and mind the difference: a line such as See docs/database-rules.md lets Claude read the file only when it needs it. An import with @docs/database-rules.md loads it at the start of every session, so it saves no context. Knowledge you only need occasionally is better placed in a skill (more on that below).

Managing context: /clear, /compact and /context

/clear starts a new conversation with an empty context window. Use it between unrelated tasks. Anthropic gives a firm rule of thumb: if you have corrected Claude twice on the same issue and it still goes wrong, start over with a better prompt that includes what you learned. By then the context is full of failed attempts.

/compact summarises the conversation so far to free up space, and you can tell it what the summary should focus on:

/compact keep the database schema and the auth flow

Claude Code also compacts automatically when the window is nearly full. The CLAUDE.md in your project root survives that: after summarising, Claude re-reads it from disk. An instruction you only gave in the conversation can disappear. Anything that must always apply belongs in that file.

/context shows as a grid where your context is going: which files, tools and memory files take up the most space.

For a quick side question there is /btw: the answer never enters the conversation history, so your context doesn't grow.

More reasoning: /effort and ultrathink

/effort sets how much effort the model puts into each response. The available levels depend on the model: recent models offer low, medium, high, xhigh and max, and there is an auto setting. The default level also differs per model: Opus 5.5, Sonnet 5.5 and Haiku 5.5 default to medium. Higher means more thorough, but also slower and more expensive.

If you want extra depth for a single request without changing the setting, put ultrathink anywhere in your prompt:

ultrathink: analyse this authentication architecture and list every scaling bottleneck

Claude Code recognises that keyword and adds an instruction for that one turn. Since version 2.1.311, typed in the terminal, the word also raises that turn to xhigh effort; you then see it in rainbow colours. Other phrases, such as "think hard" or "think more", are just text in your prompt; Claude Code does not treat them as keywords.

My rule of thumb:

Running everything at the highest level by default is mostly a way to burn tokens. Anthropic itself writes that max may show diminishing returns and is prone to overthinking; test it before using it broadly.

Plan mode: read first, then build

Press Shift+Tab until the status bar shows plan mode, or type /plan. Claude then reads files and answers questions but changes nothing. Press Ctrl+G to open the plan in your editor and adjust it yourself before Claude starts.

Read /src/auth and explain how we handle sessions and login.
I want to add Google OAuth. Which files need to change? Create a plan.

Review the plan critically; a bad plan produces bad code at high speed. But plan mode also costs time. For a small, clear change, just skip the plan.

Let Claude ask questions first

For a large or vague task it helps to have Claude ask questions before it starts. A simple addition to your prompt:

Build a CRM system.

Ask me clarifying questions until you are 95% confident you can complete this successfully.

The percentage is not a measurement; it is a way of saying: keep asking until the task is clear. Claude then asks about roles, workflows, scale, integrations and security.

Anthropic describes a more thorough version: have Claude interview you about implementation, edge cases and trade-offs, have it write the outcome as a specification to SPEC.md, and then start a new session to execute that spec.

Ask for criticism, within limits

Claude also works as a sparring partner. Ask an architecture question instead of giving a build order, or have it tear your design apart:

Destroy this architecture.
Identify every weak assumption, scaling issue,
security risk and future bottleneck.

A reviewer asked to find weaknesses almost always finds some, even when the work is sound. Anthropic warns about this itself: follow up every remark and you get extra abstraction layers, defensive code and tests for cases that cannot happen. Ask only for problems that affect correctness or the stated requirements.

Working in parallel: subagents, worktrees and /batch

Subagents

A subagent works in its own context window and reports back only a summary. That makes subagents especially useful for keeping research out of your main conversation:

Use subagents to investigate how our authentication system handles token refresh,
and whether we have any existing OAuth utilities I should reuse.

You can also define your own subagents in .claude/agents/, each with its own tools and its own model. That is where you pick, say, Haiku for simple searching and Opus for a security review. The /model command only switches the model of your main session.

Git worktrees

A worktree is a separate working directory with its own branch, linked to the same repository. Start Claude with claude --worktree feature-auth and it works in .claude/worktrees/feature-auth/; in a second terminal you start another session under a different name. The sessions don't touch each other's files. Conflicts don't disappear, though: they move to the moment you merge the branches. A worktree is a fresh checkout: files such as .env can be copied along via .worktreeinclude.

/batch

For a large, mechanical change across the whole codebase there is /batch:

/batch migrate all forms to the new design system

Claude researches the codebase, splits the work into five to thirty independent units and shows you that plan first. Once you approve, each unit gets its own subagent in its own worktree.

Make Claude check its own work

According to the documentation, this is the difference between a session you have to sit next to and one you can leave running. Without a check, Claude stops as soon as the work looks done, and you become the one who has to spot every mistake. Give it something that passes or fails: a test suite, a build, a linter, a screenshot to compare against.

Run all tests. Fix the failures and repeat until all tests pass.
Address the root cause; don't suppress errors.

Ask for evidence rather than a claim: the test output, the command it ran, a screenshot of the result.

There are built-in commands for this now. /goal with a condition, such as /goal all tests in tests/auth pass and lint is clean, makes Claude keep working until a separate model confirms after a turn that the condition holds. /verify has Claude build and run the app and look at the result; that catches problems tests and typechecks miss. And /code-review has the diff reviewed by a subagent that never saw your conversation, so it isn't swayed by the reasoning that produced the code.

Screenshots and the browser

Paste a screenshot of a design or error message into the prompt, and after building have Claude take its own screenshot, list the differences and fix them.

The Chrome integration takes this further. Start Claude Code with claude --chrome (or manage the connection with /chrome) and Claude can open pages, click, fill in forms and read console errors in a visible Chrome or Edge window. You need the Claude in Chrome extension and a plan directly with Anthropic (Pro, Max, Ultra, Team or Enterprise); an API key is not enough. Other Chromium browsers, such as Brave and Arc, work too. Claude uses the sessions you are already logged into; at a login page or CAPTCHA it stops and asks you.

Open localhost:3000, submit the signup form with invalid data
and check whether the error messages appear. Fix what's broken and test again.

Useful extras

Rewinding. Every prompt creates a checkpoint. Press Esc twice or run /rewind to restore the conversation, the code or both to an earlier point. That makes experimenting cheap. Checkpoints only track changes Claude makes through its own editing tools, not through shell commands: it is not a replacement for git.

Branching. /branch creates a branch of the current conversation so you can try another direction while the original is preserved. /fork copies the conversation into a new background session.

Advisor. /advisor opus gives Claude a stronger model it can consult at decision points, for instance before committing to an approach or when an error keeps coming back. Claude decides when. Experimental, and every consultation costs extra tokens.

Dictation. /voice turns on voice input: hold the space bar and talk. The audio is sent to Anthropic's servers for transcription.

Remote access. With /remote-control (or claude --remote-control) you follow and steer a session running on your own computer from claude.ai/code or the Claude app on your phone. Code and files stay local.

Skills: reusable ways of working

A skill is a folder in .claude/skills/ with a SKILL.md file. The difference from CLAUDE.md: a skill is loaded only when relevant, or when you invoke it with /skill-name. So it is the place for knowledge and workflows you need now and then, without paying for them in context every session. Think of a fixed approach to a security audit, a checklist for database migrations, or the steps to fix a GitHub issue.

An example of behaviour rules packaged as a skill is the Karpathy skills: four rules that make a coding assistant produce smaller, more focused changes.

Skills are no longer an Anthropic-only format: on 22 October 2026 Anthropic donated Agent Skills to the Agentic AI Foundation, as an open standard for all AI agents.

Where your time goes now

Working this way, you type less code and spend more time on three other things: scoping the task, deciding how to check that it is right, and keeping the context clean. That is less spectacular than a list of hidden features, but it is where the difference lies. A good first step: pick your next task, write down beforehand which test or command has to pass, and give Claude that check in the first prompt.

Further reading on this site

• Getting started with Claude Code in November 2026: the complete guide to Python, IDE and database
• Claude Code in PhpStorm: setup, the plugin and the habits that work
• Claude Code Routines: how they work and where the limits are
• Letting Claude Code work autonomously: auto mode, the Ralph loop and tmux
• Free high-quality images in Claude Code: the best model and the setup (November 2026)

Sources

• Claude Code documentation: best practices, including "What you can stop doing", /goal, /verify and /code-review (accessed 5 November 2026)
• Claude Code documentation: CLAUDE.md, under 200 lines, imports, /init
• Claude Code documentation: what is in context and what survives compaction
• Claude Code documentation: /effort, default levels and ultrathink
• Claude Code documentation: plan mode, Shift+Tab, Ctrl+G and auto mode
• Claude Code documentation: /btw, /context, /compact, /batch, /branch, /fork, /advisor, /voice
• Claude Code documentation: worktrees and .worktreeinclude
• Claude Code documentation: the Chrome integration
• Claude Code documentation: checkpoints and /rewind
• Anthropic: donating Agent Skills to the Agentic AI Foundation (22 October 2026)