AI Development & Programming: Build Apps with AI

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.

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 four "cut off mid-response" messages (Server error, Connection lost, Your computer went to sleep, and The response stopped arriving), 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.

Local models have been able to write code for years, but only as completion: finishing the line you were already typing. The agentic pattern, where the model reads the repository, edits several files and runs the tests, was too heavy to run at home. That changed through late 2025 and 2026, and the clearest evidence is that model developers now market for it directly: the Qwen model card names CLINE outright and ships a purpose-built function call format, while Mistral released Devstral Small 2 (24B) under Apache 2.0 alongside the 123B Devstral 2 on December 9, 2025. This article works through what is actually achievable today using primary sources only, because several roundup posts turned out to have attributed one model size's score to another. The central obstacle is a configuration detail almost nobody mentions: Ollama does not use a fixed default context length, it derives one from your VRAM, which means 4k below 24 GiB, 32k from 24 to 48 GiB and 256k above that. A typical gaming PC lands on the first row, so an agent overruns the window immediately and the start of the conversation is silently truncated. No error is raised. It forgets instructions, repeats actions and loses the goal, and the whole thing reads as a stupid model rather than a discarded context. Ollama documents at least 64000 tokens for coding tools, set via OLLAMA_CONTEXT_LENGTH, but raising it raises memory use too, so ollama ps has to confirm the model still fits on the GPU. Also covered: why Continue and Cline are different tools with different hardware demands, published scores for Qwen3.6-35B-A3B (73.4 on SWE-bench Verified, 3B active out of 35B) and Devstral Small 2 (68.0%), download sizes and memory guidance by VRAM tier, a four-step setup, why "local is at X% of the cloud" comparisons no longer hold now that the frontier side has stopped publishing SWE-bench Verified, and an honest accounting of what "free" actually costs.

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 thinks always (cannot be disabled), 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 legacy models such as Sonnet 4.5 / Haiku 4.5 still use budget_tokens as their only mode. Depth control moved to output_config: {"effort": ...} with five levels (default high), 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/4.8 only, toggled with /fast in Claude Code). Everything is grounded in Anthropic's official Thinking, Extended thinking, and Fast mode documentation.

Claude Desktop freezes mid-task and every Claude Code session you had open stops at the same moment; you force-quit it, and sometimes the app then refuses to start at all. The last line in %APPDATA%\Claude\logs\main.log is almost always the same one: GPU process gone, with exitCode 101457950 (0x060C201E). This article sets out what that code is, why sessions with nothing to do with each other go down together, and which remedies are real. The first move is a separation: Claude Code (the CLI) is not what crashed — the GPU process of the Electron desktop app that hosts it is. The second is why the damage spreads so far. Chromium concentrates rendering in a single GPU process, and there is exactly one of it per application, shared by every window, tab and session; so one heavy page opened in the in-app browser can take down eight unrelated sessions at the same instant, and no user-facing setting separates them. Triggers come next. The in-app browser dominates the public issues — #80444 records the process dying 15 to 36 seconds after a page ran WebGL/WebGPU feature detection, four times with the same exit code; #82967 pins the trigger on the browser tool's preview screenshot capture; #83478 reproduces it with a continuously refreshing preview left open. But the browser is not the only trigger: #68049 reports the same code at launch on ARM64 with no browser interaction at all, and #83028 reproduces it on an Intel integrated GPU. Diagnosis is then made concrete with three files — main.log, unknown-window.log (a CONTEXT_LOST_WEBGL at the same timestamp) and the Crashpad folder — plus a table separating 101457950 from the exit codes that mean a clean shutdown, and a warning that the requestAdapter powerPreference line in the same log is a normal Chromium message rather than a sign of a crash. Recovery covers Repair for the case where Windows marks the package Modified and refuses to launch it, alongside the report where the state reached Modified, NeedsRemediation and only a complete removal and reinstall brought the app back; saved transcripts survive, but work that was in flight does not (#81698 lost a set of parallel subagent results). It closes with what helps and what does not — --disable-gpu is rejected on the MSIX build, updating the app did not stop it here, isolating the GPU process is structurally impossible — the hybrid-GPU pinning tip and why no report of it helping with this symptom has been found, and how to tell a Store update's forced quit apart from a real crash.

A general claim cannot answer the question "if an AI can edit things directly, do we still need an admin panel?", because the single phrase "admin panel" covers a pile of features with completely different natures. This article, grounded in the experience of deleting this site's admin panel outright, replaces that question with a sharper one: does that screen provide something the CLI and the AI are not already providing? What deleting the whole thing revealed is that most of the removed features were not "unused" but "structurally broken". Article CRUD could never work, because the source of truth for articles lives in code and every deploy overwrites the database, so anything edited in the screen vanished at the next deploy. The comment approval queue was always empty because posts were marked approved on submission, so an unapproved comment never came into existence. A feature nobody uses is a feature nobody can tell is broken. The one capability that could not go was comment deletion, and even that had no inherent need to be an admin panel: a delete button on the article page itself turned out to be better, because the offending comment can be removed right where it is being read. The decision comes down to six questions. Who operates it (non-technical staff or a role that changes hands argues for a UI; developers who live in a terminal do not). Is it reversible (irreversible actions need a gate). Does it need a human judgement (is there an approve-or-reject state transition). Do permissions need separating. Does the operator know what is possible (the listing doubles as documentation). Is there an audit trail. Permissions and audit trails in particular look unnecessary on a solo project and become the first requirements the moment a second person arrives. Changes made through code land in git, but letting an AI write to the database directly records nothing by default, and a conversation log preserves what was asked rather than what happened. Of the six axes, only reversibility carries a different weight. On 18 July 2025 a Replit AI agent deleted SaaStr's production database during an active code freeze, fabricated 4,000 users and incorrectly claimed rollback was impossible, delaying recovery (AI Incident Database #1152) — a case that shows less the danger of AI than a design problem in which an irreversible action could be reached without passing a human gate. The article also covers the three things to put in place before shifting weight onto AI and the CLI (changes leave a durable artefact, a step sits in front of irreversible actions, the procedure is written down, since deleting the UI also deletes the list of what is possible), a checklist to run before building anything, and the third option of internal-tool products such as Retool and Forest Admin instead of hand-writing a panel.