AI Development & Programming: Build Apps with AI

On a corporate machine or over VPN, Claude Code fails with "Can't reach the API server — check your internet or DNS (ENOTFOUND)", "Connection refused — a firewall or proxy may be blocking it (ConnectionRefused)", "SSL certificate verification failed", or "fetch failed" — network errors where the request never reached Anthropic's server (api.anthropic.com), unlike auth (401/403), server overload (529/500), and rate limiting (429). Before v2.1.227 the same errors read "Unable to connect to API (ECONNREFUSED)" with only a code. This article covers what each current message means (including No internet route, Couldn't connect through your proxy, and Connection dropped), the first-run "Unable to connect to Anthropic services" exit (checking the named proxy variable, and the possibility that your country or region isn't supported), the "Streaming response ended before any complete data was received" warning when a proxy or gateway alters the response, the three enterprise blockers (unconfigured proxy, TLS inspection, firewall) plus DNS/VPN/Docker, proxy setup (HTTPS_PROXY/HTTP_PROXY/NO_PROXY, SOCKS unsupported, NTLM/Kerberos via an LLM gateway), TLS and corporate CAs (the v2.1.273 certificate messages, the "SSL certificate error" at /login and startup, NODE_EXTRA_CA_CERTS, mTLS), why never to use NODE_TLS_REJECT_UNAUTHORIZED=0, the firewall allowlist, and a diagnostic workflow — all based on the official error reference.

When Claude Code suddenly stops with "API Error: 529 {\"type\":\"overloaded_error\",\"message\":\"Overloaded\"}" or "500 Internal server error", these are transient server-side events — not a mistake in your request or settings, and not your usage running out. This article explains the meaning of 529 Overloaded (Anthropic API temporarily over capacity, congestion across all users) and 500 (an unexpected internal error, with related 504 timeout_error; 502/503 usually come from upstream infrastructure), the fact that neither consumes your usage quota, how Claude Code auto-retries up to 10 times with exponential backoff before showing anything (Retrying in Ns, attempt x/y; CLAUDE_CODE_MAX_RETRIES default 10, API_TIMEOUT_MS default 10 minutes), the user fixes (wait and retry, switch model with /model since capacity is per model so Sonnet often works when Opus is busy, check status.claude.com, /feedback with request_id if a 500 persists), how to tell it apart from confusable errors (529/500 = server-side and no quota used, 429 = your rate limit with a retry-after header and quota, usage limit = plan allowance, 400 = a bad request), developer guidance (typed SDK exceptions and auto-retry, exponential backoff plus jitter, honoring retry-after on 429, --fallback-model, Priority Tier/Batch), and how to tell a transient spike from a continuing incident — all based on official information.

Working in Claude Code, you suddenly see "You've hit your session limit · resets 3:45pm" and stop cold. This is not an error or a bug: it is how subscription usage limits work. The official error reference lists four versions — session (the rolling 5-hour window), weekly (the weekly window), and Opus and Sonnet (caps for one model family) — and because session and weekly limits are shared by all models, switching models does not bring access back. This article explains what the four messages mean and how the wording changed from the older "Claude usage limit reached. Your limit will reset at …", the four biggest consumption drivers (model choice, context size, long continuous sessions, subagents/MCP), five moves when you hit the cap (switch models for an Opus/Sonnet cap, trim context with /compact so the next window lasts, wait for the reset — automatic from v2.1.234 — switch to pay-as-you-go API, or use /usage-credits or upgrade), how to see what is left (/usage, the status line, Settings → Usage), look-alike messages that are not your plan limit (Server is temporarily limiting requests, spend limit), and how subscription limits differ from API limits — based on the official documentation. Exact allowance numbers change over time, so the article avoids asserting them.

Claude Code reports "Prompt is too long" when total input, including history, files, and tool results, exceeds the context limit. This article separates compacting a long history, reducing an oversized first input, and resolving an underlying compaction error such as authentication failure. MCP definitions load on demand by default, while 1M availability depends on the model, connection, and plan. It also explains token counting and stop reasons for direct API use.

When a Claude Code MCP server will not connect, check the status, connection method, and Issue details together. failed can indicate a stdio startup failure, an HTTP communication failure, or a rejected fixed authentication header. This article explains Connection closed, environment variables and undefined references, project configuration and approval, npx startup on Windows, debug logs, and operation checks after reconnecting. It also explains why zero tools is not necessarily an error and why a standalone launch does not guarantee a successful MCP connection.

During long Claude Code sessions, a stray "court" or a raw <invoke name="Bash"> tag suddenly leaks to the screen and the tool call never executes. This is not a mistake in your environment or command: it is a known model-side glitch where Claude (especially the Opus 4.8/4.7 family) corrupts the control tags of a tool call as it generates them, with many issues filed in Anthropic official repository (#64108, #64150, #64690, #65705, #66153, #67295, #68354). This article explains how an agent generates tool calls as text, why the fail-closed harness rejects them so no wrong command ever runs, the two-layer cause (control-token corruption plus a self-poisoning chain where the broken block stays in history and the model imitates it), the trigger conditions (long multi-day sessions, heavy context, the post-/compact state, multiple tools at once, 3+ MCP servers, long tool arguments), three common misconceptions (it did not go rogue; court is meaningless but a useful marker; retry only fixes mild cases), the user fix (bail to a fresh session /clear after two misses; /compact is unreliable), the developer fix (check stop_reason, detect invoke leakage and retry, never keep broken history, shorten arguments), how to tell it apart from similar errors (thinking-block 400, max_tokens truncation, third-party Bedrock parsing), and the official status that no fix has shipped as of October 4, 2026 — all grounded in official docs and the real issues.

Retraining a giant AI from scratch is too expensive, but you want to tweak it just for you; LoRA (Low-Rank Adaptation) grants that wish by freezing the original model and training only a tiny add-on part (an adapter), cutting trainable parameters to under 1% of the original model. LoRA makes fine-tuning dramatically cheaper and faster, and is hugely popular in image generation like Stable Diffusion as a small file that adds a character or style. This article explains it with a patch analogy. LoRA is the flagship of parameter-efficient fine-tuning (PEFT): leave the huge original weights frozen, insert a small add-on matrix into each layer, and train only that (W = W0 + BA, where W0 is frozen and BA is the small added part). It builds on the hypothesis that adapting an AI does not require big changes (a low rank is enough), which the original paper's experiments backed up (though some reports find it underperforms full training in math and programming). Benefits: trainable params under 1% of the original (about 1/10,000 for GPT-3 175B in the original paper), less GPU memory (1.2TB → 350GB during training in the same setting), faster and cheaper training, no inference latency once the adapter is merged, and less forgetting of the original model's abilities. Its biggest strength is swappable adapters: keep one common base and swap small LoRA files per use case (support, company tone, a specific character) instantly. Many people first meet LoRA in image generation, where Stable Diffusion LoRAs that learned a character, style, or subject are shared widely (add a style, teach a character, light and shareable). QLoRA combines quantization, training LoRA on a 4-bit base: it fine-tuned a 65B model that would need over 780GB to train fully in 16-bit on a single 48GB GPU, and a 33B model on a 24GB consumer GPU, performing on par with 16-bit methods in the paper's comparisons (the paper itself says it did not establish whether it matches full training at 33B and 65B). Versus full fine-tuning (train all weights), LoRA differs in weights trained, cost, output, and best use; for most work LoRA is enough. Keep the base, season it small. Figures come from the experimental conditions of the original papers and others; read them as directional.

A huge 70B model running on a single home PC instead of a rack of data-center GPUs (with the part that doesn't fit in a consumer GPU offloaded to the CPU and system RAM) is made possible by quantization, which lowers the numerical precision of a model's weights to dramatically shrink size and memory. Whereas model distillation moves knowledge into a separate smaller model, quantization makes the same model lighter. This article explains it with a photo-compression analogy. Quantization replaces weights stored as FP16/FP32 decimals with INT8 (8-bit) or INT4 (4-bit) integers, cutting bytes per weight (FP32=4, INT8=1, INT4=0.5); like compressing a RAW photo to JPEG, you sacrifice a little precision for a big reduction, and the surprise is how little you give up. On memory, 4-bit uses about a quarter of FP16: a 70B model drops from ~140GB to ~35GB, and an 8B model at 4-bit is ~4.5-5GB, fitting a midrange 8GB-VRAM GPU for local use (the democratization of LLMs). On accuracy, INT8 is nearly lossless and INT4 reportedly degrades under 4% on general Q&A/commonsense tasks, but loss is more noticeable for math, code generation, and hard reasoning (it shows as a small rise in perplexity), so pick the bit-width for the task. Main methods: GPTQ (pioneer of accurate 4-bit), AWQ (protects the ~1% most important weights; whether it beats GPTQ depends on the evaluation), GGUF (llama.cpp/Ollama format, Q2_K-Q8_0, CPU+GPU hybrid, for local), and QLoRA (4-bit base plus LoRA for consumer-GPU fine-tuning). It differs from distillation (move to a separate small model) and fine-tuning (add task knowledge), and the three are usually combined (quantize a distilled model; fine-tune a quantized base). To start, run a GGUF model with Ollama in one command, choose Q4/Q8 by VRAM, and avoid INT4 for code or exact math. Most major models ship already quantized, so you just download and use them. Keep the smartness, drop only the weight. Figures are quoted from public materials, directional.

A huge, high-performance AI is smart but heavy and expensive; model distillation (knowledge distillation) solves this by transferring a large teacher model's knowledge to a small student model, keeping near-teacher performance at a far smaller size and higher speed. This article explains it with a teacher-student analogy. The key is soft labels: ordinary training teaches only "the answer is cat" (hard label), while distillation passes the teacher's full probability distribution like "90% cat, 8% dog, 2% fox," whose degree of hesitation carries rich information; a temperature parameter softens the probabilities to reveal subtle relationships (real example: OpenAI's 2024 API feature for training smaller models on larger models' outputs). Benefits: fast and cheap, much more compact with near-teacher performance (TinyBERT: 7.5x smaller, over 96.8%), runs on the edge, strong for specialization. Two approaches: white-box (full access to weights and internal representations, deeper transfer; for your own or OSS models) and black-box (only outputs/API responses visible; using another company's API as teacher can violate terms). It differs from quantization (compress the same model's weight precision) and fine-tuning (further-train an existing model for a task) — distillation moves knowledge into a separate small model, and the three are combinable. The legal/ToS reality was a big 2026 issue: the technique is legitimate, but OpenAI, Anthropic, and xAI include anti-competitive distillation clauses prohibiting using outputs to build competing models, so distilling a competitor from a restricted API can violate terms. The OpenAI v. DeepSeek dispute (OpenAI alleged DeepSeek-linked accounts circumvented restrictions to obtain outputs for distillation, while DeepSeek's terms reportedly permit distilling its outputs) shows the assessment depends on whose API terms apply, and Claude Fable 5/Mythos 5 route distillation-flagged requests to a less capable Opus model. Tips: use your own or licensed OSS models as teacher, check anti-distillation clauses before using a commercial API, and judge whether the use is "developing a competing model." Smartness from the big model, operation from the small — but who you pick as teacher changes the outcome technically and legally. Figures are quoted from public materials, directional.

In "How to build a multi-agent system" we said to instrument every handoff before adding agents; the tech that powers that instrumentation in production is AI observability. It makes visible what LLMs and agents actually do in production (which model with what prompt, which tools and searches, what was returned, and how long and how much it cost) so you can trace back to the cause. The decisive difference from ordinary app monitoring: AI can return 200 OK in 50ms and still confidently hallucinate, so most AI failures are quality failures (hallucination, weak retrieval, unsafe answers, incomplete tasks, poor tool use, post-prompt-change regressions), not infrastructure failures. Observability rests on three pillars: traces (one request as a tree of spans showing LLM calls, tools, retrieval, reasoning chains; the star of AI observation), metrics (latency, cost, tokens, error rate, throughput), and logs (per-event detail). The industry standard OpenTelemetry GenAI conventions capture prompts, responses, token usage, and tool/agent calls in a vendor-neutral schema feedable into Datadog/Grafana. The most-confused distinction is observability vs evaluation (evals): observability shows what happened (easy to measure, but cannot tell if the answer is correct), while evals measure whether the answer is good (accuracy, groundedness, safety) and require explicit evaluation. Because cost and latency are easy to measure but answer quality is not, 2026 tools combine trace display with output scoring and degradation alerts. Metrics split into operational (cost, latency, tokens, error rate) and quality (hallucination, groundedness/faithfulness which is most critical for RAG, safety, task completion), with hallucination detection via LLM-as-a-judge, semantic similarity, and groundedness scores. Major tools: LangSmith (LangChain), Langfuse (open-source self-host), Arize Phoenix (RAG debugging), MLflow (lifecycle), AgentOps (agents), and OpenTelemetry (the standard). Start by capturing traces (OpenTelemetry-compliant), visualize operational metrics, then connect evals before shipping. For multi-agent systems observation is essential since failures hide in multi-step chains visible only in a full-session trace. Observe plus evaluate is what makes AI production-grade. Figures and traits are quoted from public materials, directional.

The hands-on follow-up to "What is a multi-agent system?". The core rule: build with a single agent first and add agents minimally only after hitting a limit (a Google Research study found every multi-agent setup 39–70% worse on a strictly sequential task, and Anthropic reports multi-agent systems use about 15× the tokens of a chat). The base shape is the supervisor pattern: subagents in the Claude Agent SDK, agents as tools in the OpenAI Agents SDK. Beyond the 5 steps (decompose, define workers, design the supervisor, handoffs, measure), it gives minimal code for both SDKs that follows their official docs (one supervisor plus a researcher and a reviewer), how to restrict each role's tools, three layers of caps (maxTurns, max_turns, spend), when to use handoffs instead, good and bad role splits, and failures Anthropic actually hit (50 subagents for a simple query, duplicated research) with fixes.

Now that AI agents are commonplace, the next challenge is how to make agents collaborate with each other. If MCP connects an agent to its tools, A2A (Agent2Agent) connects an agent to another agent — an open standard for AIs built on different vendors and frameworks to discover, communicate, and cooperate through a common convention. Google released it in April 2025, donated it to the Linux Foundation that June, and it reached v1.0 in 2026. This beginner guide covers what A2A is (the etiquette of a business partnership analogy), why it's needed (specialized agents relay work — a planning agent to a hotel-booking agent to a payment agent), how it differs from MCP (MCP is vertical, agent ↔ tools; A2A is horizontal, agent ↔ agent; stacking both is the standard two-layer setup), how it works (an Agent Card — a JSON "business card" at /.well-known/agent-card.json — is used to discover capabilities, then a Task carries the request through states like working, input-required, and completed, and an Artifact returns the result, all over HTTP, Server-Sent Events, and JSON-RPC 2.0, with agents keeping their internals hidden), and where it stands and implementation (as of April 2026, 150+ supporting organizations, 22,000+ GitHub stars, SDKs in five languages — Python, JavaScript, Java, Go, .NET — with Microsoft, Salesforce, SAP, and ServiceNow involved). The mnemonic: connect to tools = MCP, connect to peers = A2A.