Claude AI Guide: Tips, Tutorials & Best Practices

Projects in Claude Code has been rebuilt. Until now a project was a folder holding conversations and reference material; the new Projects is a single conversation. You write what you need, Claude splits it into threads, the threads run in parallel in the cloud, and each one opens a pull request and reports back when it finishes. Closing your laptop does not stop them. Three things are worth checking before you jump in, though: the accounts that can use it are still limited (a Pro and Max public beta, going out first to accounts with no existing projects), github.com and the Claude GitHub App are requirements in practice, and the rate at which it eats your usage limit is nothing like a single session. This article works through how to tell whether the rollout has reached you, what a thread starts with (including the trap where permission rules and hooks stop applying once a project holds more than one repository), where the token cost comes from including the default of Opus at high effort, and how to choose between the five ways to work in parallel: subagents, agent view, agent teams, dynamic workflows and Projects, all from the official documentation and blog.

You want a smart model to handle only the planning, and a faster, cheaper model to handle the implementation. Claude Code's opusplan is a model setting that does this automatically. It runs Opus while in plan mode and Sonnet the rest of the time, and you can use it with /model opusplan or with model in settings.json. However, it does not appear in the /model list, and because the model switches every time you enter or leave plan mode, each switch re-reads the whole conversation without the cache. Based on the official documentation, the CHANGELOG and GitHub issues as of September 15, 2026, this article covers how to set it up (including pinning versions and 1M context), the flow from plan mode through approval to implementation, how it was removed from the selector in v2.0.0 and what an Anthropic staff member said about it, an estimate of the cache cost a switch creates and how to keep it down, how it differs from the advisor tool and subagents, and the kinds of work it suits and doesn't.

Can you keep Claude Code's main session on Opus 5 and hand only jobs like translation or high-volume checks to Sonnet or Haiku subagents? Yes. A subagent's model is decided in this order: the model passed at invocation, model in the definition file, the CLAUDE_CODE_SUBAGENT_MODEL environment variable, then the main session's model, and effort can also be set per subagent. Based on the official documentation as of September 15, 2026, this article covers how that order differs between versions, CLAUDE_CODE_SUBAGENT_MODEL_FORCE for pinning every subagent to one model, how aliases resolve differently by provider, and the fact that since v2.1.198 the built-in Explore inherits the main session's model. It then shares what happened when I actually launched subagents on other models and checked the conversation logs: they ran on the models I specified, each one read tens of thousands of tokens just to start, the subagent cache expires after 5 minutes even on a subscription, and the same translation given to Opus 5, Sonnet 5 and Haiku 4.5 twice each differed in time, cost and quality. Finally, it summarizes how this affects cost and usage limits, and what to weigh when deciding which work to move to a cheaper model.

Run several sessions in parallel and you start to wonder which one is eating your weekly limit. Yet Claude Code's /usage only shows the current session's numbers plus your plan-wide consumption split by skill, subagent, plugin and MCP server, and what share each session used appears neither in the desktop app's usage ring nor on the claude.ai settings page (as of September 2026). The answer is in the conversation logs stored on your machine (the JSONL files in ~/.claude/projects), but adding them up as they are gives the wrong result, because a single response is written across several lines, one per content block, and subagent records live in separate files. Measured on my own machine, the naive total came to about twice the correct value, and because the size of the error differed from session to session, even the ranking changed. This article covers what the official screens do and do not show, how to count the logs correctly with an aggregation script of about 50 lines, the measured result in which one session took nearly a third of all usage, the limits of what the numbers can tell you, and how to set up OpenTelemetry if you want to keep watching over time.

You don't have to ask for "lead with the conclusion" or "keep it in plain English" every time: write it once in the instruction field that automatically applies to every conversation. That field is "Custom Instructions" in ChatGPT, "Instructions for Claude" in Claude and "Instructions for Gemini" in Gemini, but the three differ in what it is called, where it lives and how much you can write. ChatGPT allows 1,500 characters on Free and Go and 5,000 on Plus and higher plans (raised in July 2026), while Claude and Gemini don't publish a limit. This article checks the location and limit of each against the companies' official help, then uses Anthropic's official prompting guide to show how to write instructions that work, with an example. It also turns the situations the official help pages say instructions don't take effect, such as inside projects, inside Gems, in temporary chats and on company accounts, into a checklist.

You write to Claude in Spanish, Japanese or Portuguese, and the answer comes back in English. The official Claude Code repository keeps receiving the same report, and research has found that when the request and the answer are in different languages, even the strongest models fail to answer consistently in the language they were asked for. But there is more than one cause. Replies can drift into English gradually as Claude reads code and tool output, snap back to English right after compaction summarizes the conversation, turn into a different language altogether, or, since late September 2026 with Opus 5.5, switch to English only in the short messages between tool runs, and each pattern responds to a different fix. This article shows how to tell the four apart, explains why the Claude Code language setting keeps working after compaction by pinning the instruction in the system prompt, covers the hook reported to stop Pattern 4 where the setting alone did not, along with the author's logs in which English in those mid-task messages rose from about 11% to about 50%, and sorts out the problem reported from September 2026 of long sessions where the output itself breaks down, keeping confirmed information separate from what is still unconfirmed.

Install too many skills and they crowd out your context: half of that is right and half of it is wrong. According to the Claude Code documentation, the skill listing draws on a fixed budget of 1% of the model context window, and no matter how many skills you add, it stops there. Instead of growing, the listing starts dropping descriptions, beginning with the least frequently invoked skills, and keeps only their names. A skill that has lost its description no longer connects to what you asked for, and yet no error appears and nothing gets slower. This article works through the different jobs of the three measurement tools (/context, /usage and /skill-doctor), the definition of a cache miss as 5% and 2,000 tokens, how the cache lifetime falls from one hour to five minutes depending on your plan, why a CLI is still lighter than MCP now that tool definitions are lazy-loaded by default, the reasoning behind keeping CLAUDE.md under 200 lines, and what to cut first once you have measured, restricted throughout to what could be confirmed in the official documentation.

You hit a wall while using Claude, you search the exact message that appeared, and almost nothing comes back. Five strings behave this way: The model returned no content because the response was blocked by content filtering, The response was blocked by the provider's content filter, Streaming response ended before any complete data was received, Could not locate the Claude CLI on PATH, and Connection to Claude's response was lost. Claude may still be working. What they share is that they appeared while you were using Claude, yet searching Claude's own material seems to turn up nothing, and the reason is simple: the program that wrote the message on your screen is not necessarily the one you think it is. This article does not explain each individual cause from scratch. It is an entrance hall that identifies who wrote the message and routes you to the right article. It first splits the possible writers into four layers, the backend that serves the model, Claude Code itself, the launching IDE extension or wrapper, and third-party clients, and then does the matching. Two of the five turn out to be entries in Claude Code's official error reference. The official definition of the streaming message is that the headers came back but the body held no Claude API message, which is not a mid-way cut at all, and reading it as a dropped connection sends you down the wrong path. Could not locate the Claude CLI on PATH sits in a separate chapter, Wrapper and IDE errors, described as printed by the launching program rather than by Claude Code, and the real display string can be four sentences long where the official heading is one, which is why searching it returns nothing. The two content-filter strings, meanwhile, are third-party vocabulary, and OpenCode Issue #35736 reports that three completely separate failures, a Vertex 404, a socket drop, and a genuine refusal, all surface as the same blocked by content filter sentence. The wording is correct for only one of the three, so believing it and softening your prompt will never fix a misconfigured model ID. GitHub official documentation also states that input prompts and output completions pass through GitHub Copilot content filters when Claude is used, so using Claude does not mean Anthropic filtering is what stopped you. The remaining string appears in neither the official error reference nor the Remote Control documentation, so its source could not be identified; no tool is named for it, and four steps for tracing it in your own environment are given instead. What is settled and what is not is labelled throughout.

Claude Code stops partway through a response with "API Error: Connection lost mid-response. The response above may be incomplete." and searching that exact string turns up almost nothing, because the string itself is new. The official error reference states it plainly: before v2.1.227, Connection lost mid-response appeared as Connection closed mid-response, and in the same batch Response stalled mid-stream became The response stopped arriving, while Connection closed while thinking, before producing a response became Connection lost before a response was produced. The event is not new; only the word on screen changed, which is why material written under the old name still applies unchanged and why an issue search has to use both strings. Starting from that rename, this article works only from the official documentation and public issues. It covers the official definitions of the six "cut off mid-response" messages (Server error, Connection lost, Your computer went to sleep, The response stopped arriving, Part of the response never arrived, and The response stream was malformed), why the output already on screen is kept deliberately - re-sending the request could execute the same tool call twice - and why the recovery step is to reply continue rather than to start over. It then explains why nothing is retried automatically, using the official Automatic retries branch: a break before anything has completed is re-sent with exponential backoff up to ten times, a break after thinking but before any output is re-sent at most twice and then ends the turn with Connection lost before a response was produced, and a break after a block has completed is not re-sent at all. From there it maps the three layers where a stream can break - your machine and line, the path through proxies and gateways, and the server side with connection reuse - adds the easily missed fourth case of mTLS certificate rotation and its reload behaviour from v2.1.232, and gives a nine-step isolation checklist. It lists the four stream watchdog timers with their defaults (first byte 180s, event level 300s, byte level 180s, body idle five minutes) alongside CLAUDE_CODE_MAX_RETRIES, CLAUDE_CODE_RETRY_WATCHDOG, API_TIMEOUT_MS and the two stream timeout variables, while making clear that raising the retry count does not reduce this particular message. A comparison table separates eight confusable messages, and two public reports, #86473 and #85979, show raw HTTPS and curl completing while only the CLI dies with ECONNRESET. It closes by separating what is officially confirmed from what is only reported, including that builds before v2.1.222 could show this notice even when the response was in fact complete.

Migrating to Claude Fable 5.1 is not a matter of swapping the model ID and calling it done. Anthropic marks three of the changes as breaking, and two of them surface far from where they originate. The first throws immediately: passing type any or type tool to tool_choice returns 400 invalid_request_error, because forcing a call skips the reasoning this model always does and the argument quality drops with it. The second is the quiet one. Thinking blocks now record which model produced them and only carry over in one direction, so a conversation moving onto Fable 5.1 keeps its reasoning while a router or fallback that moves it back to an earlier generation loses that turn entirely. By default the API discards the unreadable blocks before the model sees them, and because the discarded tokens are neither counted in input_tokens nor billed, nothing shows up on the invoice. Making it visible takes the thinking-binding-controls-2026-08-01 beta header. The third one is the broadest: changing anything before a Fable 5.1 thinking block, including the system prompt, the tools array or any earlier message, invalidates it and every block after it. Whether that is enforced depends on when your account was created, which means a staging environment you just spun up can fail while production does not. The article also covers what did not get worse: input stays at $10 and output at $50 per million tokens, while cache reads drop to $0.25, or 0.025x base input against the 0.1x every other Claude model charges. Anthropic quotes roughly 25% lower cost on typical workloads and up to about 45% on agent-heavy work. Seven behaviors change without any code change, including fewer parallel tool calls, less progress narration at high effort, and more answers from memory at low effort, and Anthropic counts five additions, one of which is the cache read price cut handled on its own in section 5, with beta features among the remaining four that exist specifically to replace the patterns the breaking changes forbid.

Remote Control connects the Claude mobile app or claude.ai/code to a Claude Code session already running on your own machine, and the point most explanations miss is that nothing moves to the cloud: code execution and filesystem access stay local the whole time, and the phone is only a window into that session. This article works through what that design buys you and what it costs. Your local filesystem, MCP servers, tools and project configuration all stay available (typing @ autocompletes paths from the local project), the conversation and subagent progress stay in sync across terminal, browser and phone, and a sleeping laptop or a dropped connection is survivable because Claude Code reconnects and delivers queued updates once it recovers. The requirements are stricter than they look: Pro, Max, Team or Enterprise (API keys are not supported), a claude.ai login rather than a setup-token, a direct connection to api.anthropic.com, and none of the four telemetry-disabling environment variables set, which is why privacy-minded users who set DO_NOT_TRACK are told the feature is not enabled on their account. Three entry points are covered (/remote-control to carry over the current conversation, claude --remote-control, and server mode with its --spawn, --capacity 32 and --continue flags), along with the split between slash commands that work remotely and the local-only ones such as /resume, the five-minute dialog expiry that does not apply to permission prompts, and the two push-notification toggles. On security, the article is deliberate: no inbound port is ever opened, so the network attack surface all but vanishes and the risk moves to the account, the QR code is a shortcut rather than authentication, and the default gate is exactly one signed-in account, which makes a passkey the highest-value step. Transcript retention (5 years or 30 days), what to do if the phone is lost, Trusted Devices with its 18-hour sign-in window, the ten-minute server-mode timeout, the four-hour resume window, the tmux requirement on remote machines, a troubleshooting table keyed to the actual error messages, and a comparison with Dispatch round it out.

The way Claude thinks went through a generational change. The old extended thinking had you specify a token budget on every request — thinking: {"type": "enabled", "budget_tokens": N} — but the right budget differs per task and can't be guessed in advance, and changing it invalidates the prompt cache. The current adaptive thinking is one line, type: "adaptive": whether to think and how deeply is the model's own decision based on how hard the request looks. The migration was staged: budget_tokens was deprecated on Opus 4.6 / Sonnet 4.6 and is rejected with a 400 error from Opus 4.7 onward. This article condenses the per-model rules into one table — Fable 5.1 and Opus 5.5 think always (cannot be disabled), Sonnet 5.5 defaults to thinking on and rejects disabled with a 400, but between_tools turns off only up-front thinking (effort high or below), the legacy Opus 5 and Sonnet 5 default to thinking on (on Opus 5, disabling is only allowed at effort high or below), Opus 4.8 / 4.7 require an explicit adaptive setting, and models that support only extended thinking, such as Haiku 4.5 / Sonnet 4.5, still use budget_tokens as their only mode. Depth control moved to output_config: {"effort": ...} with five levels (default high on most models, medium on Opus 5.5 and Haiku 5.5), and changing effort busts the cache the same way changing the budget used to. Visibility is governed by display: the new-generation default is "omitted" (empty thinking blocks), and you are billed for the full thinking tokens either way — measure with usage.output_tokens_details.thinking_tokens; no setting ever returns the raw chain of thought. Disabling thinking on Opus 5 carries documented side effects (tool calls written as plain text, internal tags leaking), so lowering effort is the safer cost lever. Interleaved thinking — reasoning between tool calls — is automatic under adaptive, with the old beta header no longer needed. And when you need speed, fast mode runs the same Opus at about 2.5x for 2x the price (Opus 5.5/5/4.8 only, toggled with /fast in Claude Code). Everything is grounded in Anthropic's official Thinking, Extended thinking, and Fast mode documentation.