<?xml version="1.0" encoding="UTF-8"?><rss xmlns:dc="http://purl.org/dc/elements/1.1/" xmlns:content="http://purl.org/rss/1.0/modules/content/" xmlns:atom="http://www.w3.org/2005/Atom" version="2.0" xmlns:cc="http://cyber.law.harvard.edu/rss/creativeCommonsRssModule.html">
    <channel>
        <title><![CDATA[Stories by boredhead on Medium]]></title>
        <description><![CDATA[Stories by boredhead on Medium]]></description>
        <link>https://medium.com/@boredhead?source=rss-f3b18b8c91bd------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/1*mKVDUB-90gMBfYl9jnHP4g.jpeg</url>
            <title>Stories by boredhead on Medium</title>
            <link>https://medium.com/@boredhead?source=rss-f3b18b8c91bd------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Sun, 22 Nov 2026 03:51:24 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@boredhead/feed" rel="self" type="application/rss+xml"/>
        <webMaster><![CDATA[yourfriends@medium.com]]></webMaster>
        <atom:link href="http://medium.superfeedr.com/" rel="hub"/>
        <item>
            <title><![CDATA[Simple Guide to Run a Local LLM (Mac, linux, Windows)]]></title>
            <link>https://medium.com/@boredhead/simple-guide-to-run-a-local-llm-mac-linux-windows-dfe214310dc6?source=rss-f3b18b8c91bd------2</link>
            <guid isPermaLink="false">https://medium.com/p/dfe214310dc6</guid>
            <category><![CDATA[local-llm]]></category>
            <category><![CDATA[llm]]></category>
            <dc:creator><![CDATA[boredhead]]></dc:creator>
            <pubDate>Sun, 04 Oct 2026 17:28:39 GMT</pubDate>
            <atom:updated>2026-10-04T17:28:39.988Z</atom:updated>
            <content:encoded><![CDATA[<h3>Simple Guide to Run a Local LLM (Mac, Linux, Windows)</h3><p>Here’s a step-by-step guide on how to install a local LLM.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*RbWGBWgWoycrbKMkKPqt4A.png" /><figcaption>Running llms Locally</figcaption></figure><p><strong>Step 0: Install and run your first model</strong></p><p>Keep the model download to about two thirds of your memory. On an M-series Mac the model can use all of it. On Windows or Linux it wants the graphics card’s own memory and falls back to system memory, which is a lot slower. If you don’t have a graphics card, stay with small models.</p><p>Ollama gets a model answering in one command:</p><pre># Mac or Linux<br>$ curl -fsSL https://ollama.com/install.sh | sh</pre><pre># Windows (PowerShell)<br>&gt; irm https://ollama.com/install.ps1 | iex</pre><pre># then, on any system: download and start your model from the table<br>$ ollama run qwen3:4b</pre><p>The first run pulls the file once, then drops you at a prompt:</p><pre>pulling manifest<br>pulling 3e4cb1417446... 100% ▕████████████████▏ 2.6 GB<br>success<br>&gt;&gt;&gt; Explain what a context window is in two sentences.</pre><pre>A context window is the amount of text the model can look at<br>at one time, including your question and its own answer...</pre><pre>&gt;&gt;&gt; /bye                 # leaves the chat. run the same command to come back</pre><p>If you turn the Wi-Fi off and ask again, it still answers.</p><p><strong>Step 1: Size the jobs before the hardware</strong></p><p>Agents and coding made up 40% of 10,133 classified local use cases, and chat barely registered. I plan around jobs that run without me. This prompt turns a week of tasks into the numbers the rest of the setup needs:</p><pre>You are sizing a local LLM setup for me. Ask me nothing. Work from the list below.</pre><pre>MY AI TASKS LAST WEEK<br>[paste 10 to 20 real tasks: what it was, how long the input was, how often]</pre><pre>For each task output one table row:<br>task | private data? (yes/no) | input size (tokens, rough) | runs per day |<br>needs frontier reasoning? (yes/no, one-line reason) | smallest model class<br>that would do it (4B / 12B / 27B / 100B+ / frontier API)</pre><pre>Then give me three totals:<br>1. hours per day a local model would be busy<br>2. the largest context any single task needs<br>3. the share of tasks that must stay on a frontier API</pre><pre>Do not recommend hardware. Do not round up. If a task is unclear, mark it<br>&quot;unclear&quot; instead of guessing.</pre><p>On price per token, local loses to a cheap application programming interface. An M5 Ultra Mac Studio written off over three years and running around the clock comes to €1.71 to €2.22 per million output tokens. The same open model through a cloud API costs $0.47. I run local for control and for volume nobody meters, and I’d stop making the cost argument for it.</p><p><strong>Step 2: Pick hardware by memory size, then bandwidth</strong></p><p>Every generated token means reading every active weight out of memory once. The size of your memory decides which models load at all, the bandwidth sets your ceiling on tokens per second, and raw compute matters least of the three.</p><p>If the model fits in 24 to 32 GB, an NVIDIA card is faster and has better software support. Once you’re past 100 GB, a Mac Studio ends up as the cheap inference box. I’d rent first anyway: a 3090 on RunPod’s community tier is about $0.22 an hour and a 4090 about $0.34. Ten dollars of your real workload over a weekend tells you which model you need.</p><p>Mixture-of-experts models trip people up here. Their total parameter count decides how much memory you need, while the active count decides speed, so a 125B mixture-of-experts model can generate faster than a dense 27B on the same machine.</p><p><strong>Step 3: Choose the quant and budget for context</strong></p><p>Qwen 3.8 27B is 55 GB at 16-bit and 17 GB at Q4_K_M. Independent tests found no measurable loss at Q4_K_M, so that’s my default, and I only go lower when nothing else fits. Agentic tasks fall apart before trivia does.</p><p>Context cache is the other half of the memory bill, about 64 KB per token for Qwen 3.8:</p><pre># total = model file + context cache + 1 to 2 GB runtime headroom</pre><pre>context     cache     + Q4_K_M 17.4 GB    fits in 24 GB?<br>  8K        0.5 GB      17.9 GB            yes<br> 32K        2.0 GB      19.4 GB            yes<br> 64K        4.0 GB      21.4 GB            yes, tight<br>128K        8.0 GB      25.4 GB            no  -&gt; drop to IQ4_XS (15.5 GB) or a 32 GB card<br>262K       16.4 GB      33.8 GB            no  -&gt; 48 GB+ or unified memory</pre><p><strong>Step 4: Configure the runtime</strong></p><pre># 1. already installed in Step 0. check it<br>$ ollama --version</pre><pre># 2. pull and chat. 18 GB download, vision included. needs 24 GB VRAM or a 32 GB Mac<br>$ ollama run qwen3.8:27b</pre><pre># Apple Silicon: use the MLX build of the same model<br>$ ollama run qwen3.8:27b-mlx</pre><pre># 3. raise the context. the default window is only a few thousand tokens<br>$ OLLAMA_CONTEXT_LENGTH=65536 ollama serve</pre><p>That third command is the fix when the model seems to forget everything after a few pages. Ollama starts the server with a window of a few thousand tokens, though Qwen 3.8 supports 262K. On a 16 GB machine I’d start at OLLAMA_CONTEXT_LENGTH=16384.</p><p>If you want every setting exposed, run llama.cpp directly:</p><pre># --jinja  use the model&#39;s own chat template. not optional<br># -ngl 99  put every layer on the GPU<br># -c 65536 64K context, about 4 GB of cache<br>$ llama-server \<br>    -hf bartowski/Qwen3.8-27B-GGUF:Q4_K_M \<br>    --jinja \<br>    -ngl 99 \<br>    -c 65536 \<br>    --temp 0.7 --top-p 0.8 --top-k 20 \<br>    --port 8080</pre><p>I blamed the quant for a while before noticing I’d left out --jinja. Without it the model rambles past its stop token or cuts answers short. Ollama and LM Studio apply the template for you, so this only bites on llama.cpp.</p><p><strong>Step 5: Serve it as an API</strong></p><p>Ollama exposes OpenAI-compatible and Anthropic-compatible endpoints on port 11434:</p><pre>$ curl http://localhost:11434/v1/chat/completions \<br>    -H &quot;Content-Type: application/json&quot; \<br>    -d &#39;{<br>      &quot;model&quot;: &quot;qwen3.8:27b&quot;,<br>      &quot;messages&quot;: [<br>        {&quot;role&quot;: &quot;system&quot;, &quot;content&quot;: &quot;Answer in one sentence.&quot;},<br>        {&quot;role&quot;: &quot;user&quot;, &quot;content&quot;: &quot;What is memory bandwidth?&quot;}<br>      ]<br>    }&#39;</pre><p>To point Claude Code at it, add this to the settings file:</p><pre>{<br>  &quot;env&quot;: {<br>    &quot;ANTHROPIC_BASE_URL&quot;: &quot;http://localhost:11434&quot;,<br>    &quot;ANTHROPIC_AUTH_TOKEN&quot;: &quot;ollama&quot;<br>  },<br>  &quot;model&quot;: &quot;qwen3.8:27b&quot;<br>}</pre><p>Messages, streaming, tool calls, vision and thinking all work through it. You lose prompt caching, token counting, forced tool choice, PDFs and batches. Give it at least 64K of context. When turns feel slow, look at the cache before you blame the graphics card: coding agents rewrite the start of the prompt between turns, which can make the server reprocess the whole context every time.</p><p><strong>Step 6: Route the boring calls to a small model</strong></p><p>NVIDIA Research estimated that 40% to 70% of an agent’s calls could go to a small model, and that serving a 7B costs 10 to 30 times less than a 70B to 175B one. I let a 4B model pick the lane:</p><pre>from openai import OpenAI<br>import json</pre><pre>local = OpenAI(base_url=&quot;http://localhost:11434/v1&quot;, api_key=&quot;ollama&quot;)</pre><pre>ROUTER_PROMPT = &quot;&quot;&quot;You are a router. Read the task and reply with JSON only:<br>{&quot;lane&quot;: &quot;small&quot; | &quot;big&quot; | &quot;cloud&quot;, &quot;reason&quot;: &quot;&lt;max 12 words&gt;&quot;}</pre><pre>small = classify, extract, tag, rewrite, yes/no decisions, one tool call<br>big   = write or edit code, multi-step tasks, anything with private files<br>cloud = novel architecture decisions, tasks that failed twice locally</pre><pre>If unsure between two lanes, pick the cheaper one.&quot;&quot;&quot;</pre><pre>MODELS = {&quot;small&quot;: &quot;qwen3:4b&quot;, &quot;big&quot;: &quot;qwen3.8:27b&quot;}</pre><pre>def route(task: str) -&gt; str:<br>    verdict = local.chat.completions.create(<br>        model=MODELS[&quot;small&quot;],<br>        messages=[{&quot;role&quot;: &quot;system&quot;, &quot;content&quot;: ROUTER_PROMPT},<br>                  {&quot;role&quot;: &quot;user&quot;, &quot;content&quot;: task}],<br>        response_format={&quot;type&quot;: &quot;json_object&quot;},<br>        temperature=0,<br>    )<br>    lane = json.loads(verdict.choices[0].message.content)[&quot;lane&quot;]<br>    if lane == &quot;cloud&quot;:<br>        return call_frontier_api(task)        # your paid model, used rarely<br>    reply = local.chat.completions.create(<br>        model=MODELS[lane],<br>        messages=[{&quot;role&quot;: &quot;user&quot;, &quot;content&quot;: task}],<br>    )<br>    return reply.choices[0].message.content</pre><p><strong>Step 7: Measure on your own machine</strong></p><pre># Ollama: prints prompt eval rate (prefill) and eval rate (decode)<br>$ ollama run qwen3.8:27b --verbose &quot;Explain KV cache in 200 words.&quot;</pre><pre># llama.cpp: repeatable benchmark for a GGUF file<br>$ llama-bench -m Qwen3.8-27B-Q4_K_M.gguf -ngl 99</pre><pre># is the model fully on the GPU? look for &quot;100% GPU&quot;<br>$ ollama ps</pre><p>Around 20 tokens per second is usable, and 50 starts to feel comfortable. Most apps only show you decode speed and leave out prefill, which is the time spent reading your prompt. With long inputs prefill is most of the wait, and Apple Silicon suffers from it the most.</p><p>For quality I keep a file of ten tasks I already know the answers to and run every candidate model and quant through it:</p><pre>Run each task below. For every task print: the answer, then a line<br>&quot;SELF-CHECK:&quot; stating one way the answer could be wrong.</pre><pre>1. [real bug from my repo + the failing test output]<br>2. [a contract clause] -&gt; extract parties, dates, amounts as JSON<br>3. [20 support messages] -&gt; label each: billing / bug / feature / other<br>4. [a screenshot of a dashboard] -&gt; list every number you can read<br>5. [a 30-page doc] -&gt; answer three questions whose answers are on page 24<br>...<br>10. A task where the right answer is &quot;I can&#39;t tell from this input.&quot;</pre><p><strong>Step 8: Hand it work</strong></p><p>A git hook that drafts commit messages with a 3 GB model:</p><pre>#!/bin/sh<br># keep messages you typed yourself (-m, merge, amend)<br>[ -n &quot;$2&quot; ] &amp;&amp; exit 0<br>DIFF=$(git diff --staged | head -c 12000)<br>[ -z &quot;$DIFF&quot; ] &amp;&amp; exit 0</pre><pre>printf &#39;Write a git commit message for this diff.<br>Line 1: imperative summary, max 60 characters.<br>Then a blank line, then up to 3 bullets: what changed and why.<br>No preamble. No code fences.</pre><pre>%s&#39; &quot;$DIFF&quot; | ollama run qwen3:4b --think=false &gt; &quot;$1&quot;</pre><p>I keep thinking off here so the hook comes back in a second or two.</p><p>Overnight ticket triage with eight requests in parallel:</p><pre>import asyncio, csv, json<br>from openai import AsyncOpenAI</pre><pre>client = AsyncOpenAI(base_url=&quot;http://localhost:11434/v1&quot;, api_key=&quot;ollama&quot;)<br>limit = asyncio.Semaphore(8)</pre><pre>PROMPT = &quot;&quot;&quot;Label this support ticket. Reply with JSON only:<br>{&quot;category&quot;: &quot;billing&quot; | &quot;bug&quot; | &quot;feature&quot; | &quot;account&quot; | &quot;other&quot;,<br> &quot;urgency&quot;: 1 | 2 | 3,<br> &quot;needs_human&quot;: true | false,<br> &quot;summary&quot;: &quot;&lt;max 15 words&gt;&quot;}<br>urgency 3 = money lost, data lost, or cannot log in.<br>If the ticket is unclear, category is &quot;other&quot; and needs_human is true.&quot;&quot;&quot;</pre><pre>async def label(row):<br>    async with limit:<br>        r = await client.chat.completions.create(<br>            model=&quot;qwen3:4b&quot;, temperature=0,<br>            response_format={&quot;type&quot;: &quot;json_object&quot;},<br>            messages=[{&quot;role&quot;: &quot;system&quot;, &quot;content&quot;: PROMPT},<br>                      {&quot;role&quot;: &quot;user&quot;, &quot;content&quot;: row[&quot;text&quot;]}])<br>        return {**row, **json.loads(r.choices[0].message.content)}</pre><pre>async def main():<br>    rows = list(csv.DictReader(open(&quot;tickets.csv&quot;)))<br>    done = await asyncio.gather(*(label(r) for r in rows))<br>    with open(&quot;labeled.csv&quot;, &quot;w&quot;, newline=&quot;&quot;) as f:<br>        w = csv.DictWriter(f, fieldnames=done[0].keys())<br>        w.writeheader(); w.writerows(done)</pre><pre>asyncio.run(main())</pre><p>Check 50 labels by hand before trusting the rest. If you disagree with more than 5 of them, send the needs_human rows back through the 27B.</p><p>Questions across your own notes, without a vector database:</p><pre>import pathlib, numpy as np, ollama</pre><pre>docs   = [p.read_text() for p in pathlib.Path(&quot;notes&quot;).glob(&quot;**/*.md&quot;)]<br>chunks = [d[i:i + 1200] for d in docs for i in range(0, len(d), 1000)]</pre><pre>def embed(texts):<br>    v = np.array(ollama.embed(model=&quot;nomic-embed-text&quot;, input=texts)[&quot;embeddings&quot;])<br>    return v / np.linalg.norm(v, axis=1, keepdims=True)</pre><pre>index = embed(chunks)                        # run once, cache to disk if large</pre><pre>SYSTEM = &quot;&quot;&quot;Answer only from the CONTEXT. After the answer, quote the exact<br>sentence you relied on. If the context does not contain the answer, reply<br>&quot;Not in these documents.&quot; Do not use outside knowledge.&quot;&quot;&quot;</pre><pre>def ask(question, k=5):<br>    top = np.argsort(index @ embed([question])[0])[-k:][::-1]<br>    context = &quot;\n---\n&quot;.join(chunks[i] for i in top)<br>    r = ollama.chat(model=&quot;qwen3.8:27b&quot;, messages=[<br>        {&quot;role&quot;: &quot;system&quot;, &quot;content&quot;: SYSTEM},<br>        {&quot;role&quot;: &quot;user&quot;, &quot;content&quot;: f&quot;CONTEXT:\n{context}\n\nQUESTION: {question}&quot;}])<br>    return r[&quot;message&quot;][&quot;content&quot;]</pre><pre>print(ask(&quot;What notice period did we agree with the landlord?&quot;))</pre><p>I started at 1,200-character chunks and I’m still not sure about them for long contracts, where a single clause can get split across two. Most of the tuning ends up being chunk size and what you put in front of the model.</p><p>Invoice photo to JSON:</p><pre>import json, ollama</pre><pre>SCHEMA = {<br>  &quot;type&quot;: &quot;object&quot;,<br>  &quot;properties&quot;: {<br>    &quot;vendor&quot;:   {&quot;type&quot;: &quot;string&quot;},<br>    &quot;date&quot;:     {&quot;type&quot;: &quot;string&quot;, &quot;description&quot;: &quot;YYYY-MM-DD&quot;},<br>    &quot;currency&quot;: {&quot;type&quot;: &quot;string&quot;},<br>    &quot;total&quot;:    {&quot;type&quot;: &quot;number&quot;},<br>    &quot;line_items&quot;: {&quot;type&quot;: &quot;array&quot;, &quot;items&quot;: {&quot;type&quot;: &quot;object&quot;, &quot;properties&quot;: {<br>        &quot;name&quot;: {&quot;type&quot;: &quot;string&quot;}, &quot;amount&quot;: {&quot;type&quot;: &quot;number&quot;}}}},<br>    &quot;unreadable&quot;: {&quot;type&quot;: &quot;array&quot;, &quot;items&quot;: {&quot;type&quot;: &quot;string&quot;}}<br>  },<br>  &quot;required&quot;: [&quot;vendor&quot;, &quot;date&quot;, &quot;currency&quot;, &quot;total&quot;, &quot;unreadable&quot;]<br>}</pre><pre>r = ollama.chat(<br>    model=&quot;qwen3.8:27b&quot;,<br>    format=SCHEMA,<br>    options={&quot;temperature&quot;: 0},<br>    messages=[{&quot;role&quot;: &quot;user&quot;,<br>               &quot;content&quot;: &quot;Extract the invoice fields. List any field you &quot;<br>                          &quot;could not read clearly under &#39;unreadable&#39;. Never guess a number.&quot;,<br>               &quot;images&quot;: [&quot;invoice.jpg&quot;]}])</pre><pre>print(json.loads(r[&quot;message&quot;][&quot;content&quot;]))</pre><p>Without the unreadable field, a vision model fills a blurry figure with a number that looks right. Do the totals-versus-line-items check in code, not in the prompt.</p><p>A coding agent with one skill and one Model Context Protocol server:</p><pre>---<br>name: local-review<br>description: Review the staged diff before a commit. Use when the user says<br>  &quot;review&quot;, &quot;check my changes&quot;, or asks whether something is safe to commit.<br>---<br># Local review</pre><pre>1. Run `git diff --staged`. If it is empty, say so and stop.<br>2. Read every changed file in full, not only the diff hunks.<br>3. Report in this order: bugs, missing tests, risky changes. Max 10 lines.<br>4. For each bug give file:line and a one-line fix. Do not edit any file.<br>5. If you are not sure something is a bug, label it &quot;unsure&quot;.<br>6. End with one word on its own line: COMMIT or HOLD.</pre><pre>{<br>  &quot;mcpServers&quot;: {<br>    &quot;docs&quot;: {<br>      &quot;command&quot;: &quot;npx&quot;,<br>      &quot;args&quot;: [&quot;-y&quot;, &quot;@modelcontextprotocol/server-filesystem&quot;, &quot;./docs&quot;]<br>    }<br>  }<br>}</pre><p>The model rereads every tool definition on every turn, and locally you pay for that in prefill. I stick to one or two servers, since ten is how you end up waiting 40 seconds for the agent to say hello.</p><p>A nightly digest built from yesterday’s commits and open TODOs:</p><pre>#!/bin/sh<br>cd ~/code/myrepo || exit 1<br>{<br>  echo &quot;COMMITS SINCE YESTERDAY:&quot;<br>  git log --since=yesterday --pretty=&#39;%h %an %s&#39;<br>  echo<br>  echo &quot;OPEN TODOS:&quot;<br>  grep -rn &quot;TODO&quot; src | head -50<br>} | ollama run qwen3.8:27b --think=false &quot;Write a morning digest in markdown.<br>Sections: Shipped yesterday / Looks unfinished / Do first today (3 items).<br>Use only facts from the input. If the input is empty, write &#39;Nothing new.&#39;&quot; \<br>  &gt; ~/digests/$(date +%F).md</pre><pre># schedule it: crontab -e<br># 30 6 * * * ~/bin/nightly-digest.sh</pre><p>Pipe in a competitor’s changelog or a raw meeting transcript instead and the same script handles those too.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=dfe214310dc6" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[How to Build AI Agents 101. Full Guide.]]></title>
            <link>https://medium.com/@boredhead/how-to-build-ai-agents-101-full-guide-3e23c42352f0?source=rss-f3b18b8c91bd------2</link>
            <guid isPermaLink="false">https://medium.com/p/3e23c42352f0</guid>
            <category><![CDATA[ai-agents-in-action]]></category>
            <category><![CDATA[ai-agent-development]]></category>
            <category><![CDATA[ai-agent]]></category>
            <dc:creator><![CDATA[boredhead]]></dc:creator>
            <pubDate>Fri, 15 May 2026 11:06:39 GMT</pubDate>
            <atom:updated>2026-05-15T11:06:39.131Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*OHaWV4KX0dASBMv3" /></figure><p>Most agent frameworks wrap an API call. agentic-harness is a runtime. The difference shows up the first time a session runs for two hours, a remote sandbox drops mid-task, or the context window fills without compaction configured.</p><p>The codebase is two Rust crates. One SDK, one CLI. Your agent is a binary that starts with use agentic_harness::prelude::*. cargo build is the full pipeline. No bundler, no transpile, no language runtime on the target machine.</p><p><strong>The three-layer architecture</strong></p><p>Three concentric rings. Your code is the outer ring: handlers that receive an AgentContext, call sessions, read and write files, run shell commands, spawn tasks. You never touch an HTTP client or parse a model response directly.</p><p>The harness is the middle ring. It manages session persistence, context compaction, role and skill discovery, and model selection through a provider-neutral ModelClient trait. Swap Anthropic for OpenAI for a local Ollama instance without touching handler code. Every failure mode that shows up in production, session state, context overflow, provider failures, concurrent request ordering, gets absorbed here.</p><p>Execution targets are the inner ring. Local filesystem, CI checkout, HttpSessionEnv pointed at Daytona or E2B, Cloudflare Worker boundary. Your handlers call session.shell() and session.write(). The harness translates those to whatever the target needs. When E2B releases a new API version, you update the connector, not your agent logic.</p><p><strong>Runtime config</strong></p><p>Before any handler, runtime.json in your workspace:</p><pre>{<br>  &quot;defaultModel&quot;: &quot;anthropic/claude-sonnet-4-6&quot;,<br>  &quot;openaiCompatibleModels&quot;: [&quot;anthropic/claude-sonnet-4-6&quot;],<br>  &quot;providers&quot;: {<br>    &quot;anthropic&quot;: {<br>      &quot;baseUrl&quot;: &quot;https://api.anthropic.com/v1&quot;,<br>      &quot;apiKeyEnv&quot;: &quot;ANTHROPIC_API_KEY&quot;<br>    }<br>  }<br>}</pre><p>Load it in app():</p><pre>fn app() -&gt; Result&lt;AgentApp, AgenticHarnessError&gt; {<br>    Ok(AgentApp::new()<br>        .with_workspace(&quot;.&quot;)<br>        .load_workspace_context()?)<br>}</pre><p>Model selection follows this precedence: PromptOptions::model() per call, then the role&#39;s model metadata, then defaultModel. If a model isn&#39;t in openaiCompatibleModels, you get a clean error at startup instead of a confusing failure mid-session. Never write a literal API key into the config. The harness reads apiKeyEnv at request time, so you rotate keys without restarting the server.</p><p><strong>Agent identity is a URL path</strong></p><p>No registry, no UUID system. Your agent’s identity is POST /agents/&lt;name&gt;/&lt;id&gt;.</p><pre># start a session or continue an existing one<br>curl http://localhost:3583/agents/codebot/pr-review-447 \<br>  -H &quot;Content-Type: application/json&quot; \<br>  -d &#39;{&quot;pr_number&quot;: 447, &quot;repo&quot;: &quot;my-org/my-repo&quot;}&#39;</pre><pre># same id = same session, history carries over<br>curl <a href="http://localhost:3583/agents/codebot/pr-review-447">http://localhost:3583/agents/codebot/pr-review-447</a> \<br>  -H &quot;Content-Type: application/json&quot; \<br>  -d &#39;{&quot;message&quot;: &quot;also check the migration files&quot;}&#39;</pre><pre># different id = fresh session, clean history<br>curl <a href="http://localhost:3583/agents/codebot/pr-review-512">http://localhost:3583/agents/codebot/pr-review-512</a> \<br>  -H &quot;Content-Type: application/json&quot; \<br>  -d &#39;{&quot;pr_number&quot;: 512, &quot;repo&quot;: &quot;my-org/my-repo&quot;}&#39;</pre><p>Every caller already knows how to construct a meaningful ID from context. A PR number. A run ID. A user handle. The URL is the session. The handler reads it with ctx.id():</p><pre>.agent(AgentDefinition::webhook(&quot;codebot&quot;, |ctx: AgentContext| {<br>    let session = ctx.session_with_id(ctx.id());<br>    let result = session.prompt(&quot;Review the changes in this PR.&quot;)?;<br>    Ok(json!({ &quot;review&quot;: result.text() }))<br>}))</pre><p><strong>Sessions</strong></p><p>A session holds message history, workspace file access, shell execution, tool registrations, the assigned role, and the compaction budget. Basic calls:</p><pre>let response = session.prompt(&quot;Summarize the recent changes to the auth module.&quot;)?;<br>let content = session.read(&quot;src/auth/mod.rs&quot;)?;<br>session.write(&quot;docs/auth-summary.md&quot;, &amp;response.text())?;<br>let test_output = session.shell(&quot;cargo test auth -- --nocapture 2&gt;&amp;1 | tail -50&quot;)?;<br>let matches = session.grep(&quot;unwrap()&quot;, &quot;src/&quot;, Some(&quot;*.rs&quot;))?;<br>let entries = session.readdir(&quot;src/auth/&quot;)?;</pre><p>Sessions persist across HTTP calls when you use the same ID. Call the same endpoint three times with the same session ID and the model sees all three exchanges as one continuous conversation. History accumulates automatically.</p><p>For large context alongside a prompt:</p><pre>let src = session.read(&quot;src/payments/processor.rs&quot;)?;<br>let tests = session.read(&quot;tests/payments_test.rs&quot;)?;</pre><pre>let analysis = session.prompt(format!(<br>    &quot;Here is the payments processor:\n\nrust\n{src}\n\n\n\<br>     Here are the tests:\n\nrust\n{tests}\n\n\n\<br>     The integration tests are failing in CI. Identify all the places \<br>     where an error is silently swallowed that could cause intermittent failures.&quot;<br>))?;</pre><p><strong>Tasks: the primitive most people skip</strong></p><p>A task is a one-shot child session. Fresh history, shared workspace, returns a result to the parent. The parent’s history never sees any of the task’s intermediate reasoning.</p><p>This is the difference between agents that stay coherent across long jobs and agents that start hallucinating halfway through. Run exploratory analysis inside a long-running session and the history fills with partial answers and model reasoning about things that are no longer relevant. The model anchors on that noise. Compaction eventually fires and drops context you needed. Tasks are the fix.</p><pre>let research = session.task(<br>    &quot;Read the files in src/auth/ and produce a complete summary of the public \<br>     interface surface: every public function, its signature, its documented \<br>     behavior, and any preconditions or invariants the caller must respect.&quot;,<br>    TaskOptions::new().role(&quot;code-reader&quot;),<br>)?;</pre><pre>let plan = session.prompt(format!(<br>    &quot;Here is the auth module&#39;s complete public surface:\n\n{}\n\n\<br>     Now draft an implementation plan for adding OAuth2 PKCE support \<br>     that does not break any of the existing public API contracts. \<br>     List every function you&#39;ll need to add or modify, and explain \<br>     the sequencing.&quot;,<br>    research.text()<br>))?;</pre><p>The research task runs in isolation. Its entire reasoning chain stays inside the task. The parent session gets one clean summary.</p><p>The rule: if the sub-problem has a clear deliverable and doesn’t need the parent’s conversation history to complete, make it a task. The threshold is lower than you think.</p><p>For parallel analysis across a codebase, fan tasks out and collect results:</p><pre>let src = PathBuf::from(&quot;src&quot;);<br>let mut sections = Vec::new();</pre><pre>for entry in session.readdir(&amp;src)?.into_iter().filter(|e| e.is_dir) {<br>    let child = session.task_with_id(<br>        format!(&quot;module-{}&quot;, entry.name),<br>        format!(<br>            &quot;Summarize the public surface of src/{name}. \<br>             List: all exported types and their purpose, all public functions \<br>             with signatures, cross-module imports this module depends on, \<br>             and any global state or shared resources it touches.&quot;,<br>            name = entry.name,<br>        ),<br>        TaskOptions::new().role(&quot;module-summarizer&quot;),<br>    )?;<br>    sections.push(format!(&quot;## {}\n\n{}\n&quot;, entry.name, child.text()));<br>}</pre><pre>session.write(&quot;ARCHITECTURE.md&quot;, &amp;sections.join(&quot;\n&quot;))?;</pre><p>12 modules, 12 focused tasks, each starting with zero baggage from the others.</p><p><strong>Roles and skills</strong></p><p>Roles live in .agentic-harness/roles/. Skills live in .agents/skills/. Both are auto-discovered at startup.</p><p>A role is a system-prompt overlay scoped to a call. Applied at call time, discarded after. Never persists into message history.</p><p>Precedence chain: call role, session role, agent role, no role.</p><pre>// agent-level default<br>AgentDefinition::webhook(&quot;reviewer&quot;, handler)<br>    .with_role(&quot;code-reviewer&quot;)</pre><pre>// session-level override<br>let session = ctx.session_with_id(ctx.id())<br>    .with_role(&quot;senior-reviewer&quot;);</pre><pre>// call-level override for one prompt<br>let result = session.prompt_with_options(<br>    &quot;Explain what this function does in plain English.&quot;,<br>    PromptOptions::new().role(&quot;explainer&quot;),<br>)?;</pre><p>Role file:</p><pre>&lt;!-- .agentic-harness/roles/code-reviewer.md --&gt;<br>---<br>model: anthropic/claude-opus-4-7<br>---</pre><pre>you are a senior software engineer reviewing a pull request for a rust codebase.</pre><pre>focus on:<br>- correctness: does the code do what the commit message claims?<br>- error handling: are all error paths handled, not just the happy path?<br>- security: injection risks, auth bypass conditions, improper secret handling<br>- readability: will the next developer understand this change in six months?</pre><pre>do not comment on formatting, whitespace, or variable naming conventions.<br>do not suggest micro-optimizations unless they affect correctness.<br>be specific: when you flag a problem, cite the exact file and line number,<br>explain why it matters, and suggest the minimal change that fixes it.</pre><p>The model frontmatter routes specific roles to specific models. Your explainer role runs on claude-sonnet-4-6 for speed. Your security auditor runs on claude-opus-4-7 for depth. Configure once in the role file.</p><p>Skills are markdown files in .agents/skills/. The harness picks them up automatically. The model reads them before every session. Edit the markdown, behavior updates on the next run, no recompile.</p><pre>&lt;!-- .agents/skills/commit-style.md --&gt;</pre><pre>when writing commit messages for this repository:</pre><pre>- use conventional commits: feat:, fix:, chore:, docs:, refactor:, test:<br>- keep the subject line under 72 characters, present tense imperative<br>- if the change touches more than one module, list them in the body with<br>  a one-sentence explanation for each<br>- never use &quot;update&quot; or &quot;changes&quot; as the entire message — be specific about<br>  what changed and why</pre><pre>examples of good commit messages:<br>  feat(auth): add PKCE flow to OAuth2 client<br>  fix(payments): handle stripe webhook signature mismatch on retry<br>  chore(deps): upgrade tokio to 1.38 for async-trait compatibility<br>  refactor(sessions): extract compaction logic into standalone module</pre><p><strong>The coding agent loop</strong></p><pre>agentic-harness code --workspace . --llm auto \<br>  --prompt &quot;Add a --dry-run flag to the deploy command that prints \<br>            the complete list of changes that would be made without \<br>            actually making them. The flag should work with all three \<br>            deploy subcommands: prod, staging, and preview.&quot; \<br>  --deny-path .env \<br>  --deny-path .agentic-harness/secrets/ \<br>  --deny-path config/production.yaml \<br>  --approve-dependencies \<br>  --commit &quot;feat(deploy): add --dry-run flag to all deploy subcommands&quot; \<br>  --pr</pre><p>--workspace . sandboxes all file operations at the harness level, not by trusting the model to self-restrict. --deny-path matches by prefix, so --deny-path config/ covers everything under it. Audit your workspace before the first run and enumerate every path holding secrets or production config. --approve-dependencies allows Cargo.toml modifications without a human approval step. --commit auto-stages and commits on a successful run. --pr opens a pull request, requires a clean git state and a real branch.</p><p>The loop: Inspect, Brief, large language model + Tools, Edit + Test, Commit and PR. Every run writes six artifacts to .agentic-harness/runs/&lt;id&gt;/: coding-brief.md, summary.md, run.json, events.jsonl, diff.patch, checks.json. Treat these as structured logs. run.json at 2KB gives you the model used, token costs, and exit status. events.jsonl gives you every tool call in order when you need to debug a bad run.</p><p>For CI:</p><pre># .github/workflows/agent-task.yml<br>- name: checkout on real branch<br>  run: git checkout -b &quot;agent/task-${{ github.run_id }}&quot;</pre><pre>- name: run coding agent<br>  run: |<br>    agentic-harness code \<br>      --workspace . \<br>      --llm auto \<br>      --prompt &quot;$(cat .agentic-harness/current-task.md)&quot; \<br>      --deny-path .env \<br>      --deny-path config/production.yaml \<br>      --commit &quot;chore: automated task run-${{ github.run_id }}&quot; \<br>      --pr \<br>      --output-json &gt; result.json<br>  env:<br>    ANTHROPIC_API_KEY: ${{ secrets.ANTHROPIC_API_KEY }}</pre><pre>- name: check result<br>  run: cat result.json | jq &#39;.success, .pr_url, .token_costs&#39;</pre><p><strong>HttpSessionEnv: local binary, remote execution</strong></p><p>The agent binary runs on your machine or in CI. Filesystem and shell operations execute inside a remote sandbox. The agent doesn’t know which.</p><pre>use agentic_harness::HttpSessionEnv;</pre><pre>let sandbox = HttpSessionEnv::new(<br>    std::env::var(&quot;SANDBOX_URL&quot;)?,<br>    &quot;/workspace&quot;<br>)<br>.header(&quot;Authorization&quot;,<br>    format!(&quot;Bearer {}&quot;, std::env::var(&quot;SANDBOX_TOKEN&quot;)?));</pre><pre>let session = ctx.session_with_id_and_env(&quot;repro-task&quot;, sandbox);</pre><p>From here, every file and shell operation goes over HTTP to the sandbox. The call sites look identical to local:</p><pre>session.shell(&quot;git clone https://github.com/my-org/my-repo /workspace/repo&quot;)?;<br>session.shell(&quot;cd /workspace/repo &amp;&amp; git checkout the-failing-branch&quot;)?;<br>let test_output = session.shell(<br>    &quot;cd /workspace/repo &amp;&amp; cargo test --no-fail-fast 2&gt;&amp;1 | tail -200&quot;<br>)?;<br>session.write(<br>    &quot;/workspace/repro-report.md&quot;,<br>    &amp;format!(<br>        &quot;## reproduction report\n\nbranch: the-failing-branch\nexit code: {}\n\n\n{}\n\n&quot;,<br>        test_output.status,<br>        test_output.stdout<br>    )<br>)?;</pre><p>Every operation, exec, read, write, edit, grep, glob, stat, readdir, mkdir, rm, has a defined JSON over HTTP request/response shape. Any sandbox implementing that protocol works as an HttpSessionEnv target.</p><p>The performance issue nobody warns you about: every shell call over HttpSessionEnv is a network round trip. A tight loop at three shell calls per iteration accumulates latency fast. Fix it by batching into a script:</p><pre>session.write(&quot;/workspace/agent-check.sh&quot;, r#&quot;<br>#!/bin/bash<br>set -e<br>cd /workspace/repo<br>cargo fmt --check 2&gt;&amp;1<br>cargo clippy -- -D warnings 2&gt;&amp;1<br>cargo test --no-fail-fast 2&gt;&amp;1 | tail -100<br>&quot;#)?;<br>session.shell(&quot;chmod +x /workspace/agent-check.sh&quot;)?;</pre><pre>// one call per iteration instead of three<br>let result = session.shell(&quot;/workspace/agent-check.sh&quot;)?;</pre><p><strong>Build targets</strong></p><pre>agentic-harness build --target native      # self-contained binary + manifest.json<br>agentic-harness build --target node        # native binary wrapped by node server.mjs<br>agentic-harness build --target cloudflare  # Cloudflare Worker boundary + WASM adapter</pre><p>Native is the default. One binary, one manifest, nothing else required on the target machine.</p><p>Node is for hosting platforms that require a Node entrypoint. The build generates server.mjs that starts the native Rust binary as a child process and proxies HTTP to it. The agent logic still runs as Rust. The Node layer is a 30-line HTTP shim.</p><p>Cloudflare compiles handlers to WebAssembly via the WASM JSON ABI. Durable Object bindings handle session persistence via Cloudflare KV. Workers don’t support long-running shell commands and have no real filesystem. Use --target cloudflare for webhook handling, lightweight routing, and Durable Object state management. Anything that needs cargo test delegates to a native process or remote sandbox.</p><p>Decision matrix: shipping an agent as an API other services call, use native behind nginx. Hosting on Railway or Render, use node. Webhook ingestion and lightweight routing, use cloudflare. Everything else, native.</p><p><strong>Schema-guided output</strong></p><p>Asking the model to return JSON and hoping it does is half the solution. Having the harness extract, validate, and deserialize it into a typed Rust struct is the full solution.</p><pre>#[derive(Deserialize)]<br>struct SecurityAudit {<br>    vulnerabilities: Vec&lt;Vulnerability&gt;,<br>    severity: Severity,<br>    immediate_action_required: bool,<br>    recommended_fix: String,<br>}</pre><pre>#[derive(Deserialize)]<br>struct Vulnerability {<br>    file: String,<br>    line: Option&lt;u32&gt;,<br>    category: String,<br>    description: String,<br>}</pre><pre>#[derive(Deserialize)]<br>#[serde(rename_all = &quot;lowercase&quot;)]<br>enum Severity { Low, Medium, High, Critical }</pre><pre>let audit: SecurityAudit = session.prompt_json_with_options(<br>    &quot;Review the authentication module for security vulnerabilities. \<br>     Specifically look for: SQL/command injection risks, auth bypass conditions, \<br>     improper secret handling in logs or error messages, and missing input validation.&quot;,<br>    PromptOptions::new().result_schema(json!({<br>        &quot;type&quot;: &quot;object&quot;,<br>        &quot;required&quot;: [&quot;vulnerabilities&quot;, &quot;severity&quot;,<br>                     &quot;immediate_action_required&quot;, &quot;recommended_fix&quot;],<br>        &quot;properties&quot;: {<br>            &quot;vulnerabilities&quot;: {<br>                &quot;type&quot;: &quot;array&quot;,<br>                &quot;items&quot;: {<br>                    &quot;type&quot;: &quot;object&quot;,<br>                    &quot;required&quot;: [&quot;file&quot;, &quot;category&quot;, &quot;description&quot;],<br>                    &quot;properties&quot;: {<br>                        &quot;file&quot;: { &quot;type&quot;: &quot;string&quot; },<br>                        &quot;line&quot;: { &quot;type&quot;: &quot;integer&quot; },<br>                        &quot;category&quot;: { &quot;type&quot;: &quot;string&quot; },<br>                        &quot;description&quot;: { &quot;type&quot;: &quot;string&quot; }<br>                    }<br>                }<br>            },<br>            &quot;severity&quot;: { &quot;enum&quot;: [&quot;low&quot;, &quot;medium&quot;, &quot;high&quot;, &quot;critical&quot;] },<br>            &quot;immediate_action_required&quot;: { &quot;type&quot;: &quot;boolean&quot; },<br>            &quot;recommended_fix&quot;: { &quot;type&quot;: &quot;string&quot; }<br>        }<br>    })),<br>)?;</pre><pre>if audit.immediate_action_required {<br>    let body = format!(<br>        &quot;severity: {:?}\n\n{}\n\nvulnerabilities:\n{}&quot;,<br>        audit.severity,<br>        audit.recommended_fix,<br>        audit.vulnerabilities.iter()<br>            .map(|v| format!(&quot;- {}: {} ({})&quot;, v.file, v.description, v.category))<br>            .collect::&lt;Vec&lt;_&gt;&gt;()<br>            .join(&quot;\n&quot;)<br>    );<br>    session.shell(&amp;format!(<br>        &quot;gh issue create --title &#39;security: {} vulnerabilities found in auth module&#39; \<br>         --label security --label priority-high --body &#39;{}&#39;&quot;,<br>        audit.vulnerabilities.len(),<br>        body.replace(&quot;&#39;&quot;, &quot;\\&#39;&quot;)<br>    ))?;<br>}</pre><p>If the model returns something that doesn’t match the schema, you get PromptError::SchemaValidationFailed instead of a panic three call sites later when you access a missing field.</p><p><strong>Model Context Protocol tools</strong></p><pre>use agentic_harness::McpServerOptions;</pre><pre>let sentry = ctx.connect_mcp(<br>    &quot;sentry&quot;,<br>    McpServerOptions::new(&quot;https://mcp.sentry.io/mcp&quot;)<br>        .header(&quot;Authorization&quot;,<br>                format!(&quot;Bearer {}&quot;, std::env::var(&quot;SENTRY_TOKEN&quot;)?)),<br>)?;</pre><pre>let session = ctx.session_with_id(ctx.id()).with_tools(sentry);</pre><p>Wire multiple servers to one session:</p><pre>let sentry = ctx.connect_mcp(&quot;sentry&quot;,<br>    McpServerOptions::new(&quot;https://mcp.sentry.io/mcp&quot;)<br>        .header(&quot;Authorization&quot;, format!(&quot;Bearer {}&quot;, std::env::var(&quot;SENTRY_TOKEN&quot;)?)))?;</pre><pre>let linear = ctx.connect_mcp(&quot;linear&quot;,<br>    McpServerOptions::new(&quot;https://mcp.linear.app/mcp&quot;)<br>        .header(&quot;Authorization&quot;, format!(&quot;Bearer {}&quot;, std::env::var(&quot;LINEAR_TOKEN&quot;)?)))?;</pre><pre>let session = ctx.session_with_id(ctx.id())<br>    .with_tools(sentry)<br>    .with_tools(linear);</pre><pre>let result = session.prompt(<br>    &quot;Find the top 3 errors from the last hour, ranked by volume. \<br>     For each one, create a Linear issue in the Infrastructure project \<br>     with priority High. Set the title to the error message and include \<br>     the stack trace in the description.&quot;<br>)?;</pre><p>The model calls tools based on their descriptions. A description that says “call this before responding to any question about errors, incidents, or production issues” gets called reliably. A description that says “search sentry” gets called inconsistently. If you control the server, write prescriptive descriptions.</p><p><strong>Connectors</strong></p><p>Instead of writing adapter code by hand against an unfamiliar API, pipe a connector recipe to your coding agent:</p><pre>agentic-harness add                            # list available connectors<br>agentic-harness add daytona | claude           # pipe recipe to Claude Code<br>agentic-harness add e2b     | codex            # pipe recipe to Codex<br>agentic-harness add https://e2b.dev/docs \<br>  --category sandbox | claude                  # pipe raw docs + category hint</pre><p>The recipe is a structured description of the sandbox API and the SessionEnv contract it needs to satisfy. The coding agent reads it, writes the Rust adapter module, handles authentication, wraps the provider lifecycle, and exposes it as an HttpSessionEnv. You review the diff, merge it, and the adapter lives in your project.</p><pre>let sandbox = DaytonaSandboxConnector::new(<br>    std::env::var(&quot;DAYTONA_API_URL&quot;)?,<br>    std::env::var(&quot;DAYTONA_API_KEY&quot;)?,<br>)?;<br>let session = ctx.session_with_id_and_env(&quot;task-id&quot;, sandbox);</pre><p><strong>Compaction</strong></p><p>Long sessions accumulate history. Configure compaction correctly or the harness drops context at the wrong moment.</p><pre>let response = session.prompt_with_options(<br>    &quot;Continue implementing the remaining endpoints from the plan.&quot;,<br>    PromptOptions::new().compaction(<br>        CompactionSettings::new()<br>            .context_window_tokens(128_000)<br>            .reserve_tokens(16_384)<br>            .keep_recent_messages(12),<br>    ),<br>)?;</pre><p>context_window_tokens is the total budget. reserve_tokens holds back headroom for the model&#39;s response. keep_recent_messages is the tail that survives verbatim regardless of compaction. When history exceeds the budget, the harness asks the model to summarize everything between the system prompt and the kept tail. That summary replaces the middle section.</p><p>The tradeoff: summaries lose precision. A specific decision made 50 messages ago might survive as a vague approximation. If that precision is load-bearing, write it to a file before it gets compacted away:</p><pre>session.write(<br>    &quot;.agentic-harness/decisions.md&quot;,<br>    &quot;## auth library\n\nchose authlib over fastapi-users.\n\<br>     reason: only library with PKCE support compatible with axum middleware.\n\<br>     do not revisit this decision.\n\n&quot;<br>)?;</pre><p>Files survive compaction. History doesn’t need to carry everything if the workspace does.</p><p>Run agentic-harness doctor to get your model&#39;s actual reported context window. Set context_window_tokens to 80-90% of that value. The token counter isn&#39;t perfectly accurate, and a single large file read can push you over if you&#39;re sitting at 99%.</p><p><strong>Common failure modes</strong></p><p>Session history contamination: exploratory analysis inside a long session poisons later prompts with reasoning noise from the exploration phase. Fix: use tasks. Task history never touches the parent.</p><p>Role precedence surprises: a call-level role shadows the session role and the model behaves differently than expected. Fix: session role sets identity, call role narrows focus. They layer.</p><p>--deny-path gaps: you deny .env but secrets also live in .env.local and config/staging.yaml. Fix: deny prefixes, not filenames.</p><p>Detached HEAD in CI: the agent edits, tests pass, commit fails because there’s no branch. Fix: git checkout -b agent-run-$RUN_ID before invoking the harness.</p><p>Runtime config loaded after handler registration: a handler runs before load_workspace_context(), no model registered, the error looks nothing like a config problem. Fix: always call load_workspace_context() in app() before wiring agents.</p><p>Context budget underestimation: compaction fires mid-task, the model loses its plan and improvises from the summary. Fix: run agentic-harness doctor, set budget to 80-90% of the actual window.</p><h3>Subscribe to Get More Such Updates</h3><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=3e23c42352f0" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[The most important file in Claude Code: a full guide to CLAUDE.md]]></title>
            <link>https://medium.com/@boredhead/the-most-important-file-in-claude-code-a-full-guide-to-claude-md-1fe94d0a30d9?source=rss-f3b18b8c91bd------2</link>
            <guid isPermaLink="false">https://medium.com/p/1fe94d0a30d9</guid>
            <category><![CDATA[claude-code]]></category>
            <category><![CDATA[claude]]></category>
            <category><![CDATA[claude-ai]]></category>
            <dc:creator><![CDATA[boredhead]]></dc:creator>
            <pubDate>Tue, 21 Apr 2026 19:50:31 GMT</pubDate>
            <atom:updated>2026-04-21T19:50:31.682Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*AqZ0OTii4AX-Z0HVcyEYEw.png" /></figure><p>Claude.md is the most important file in your Repo. It loads when the claude session start. Never miss it.</p><p>Here is what a CLAUDE.md file does.</p><h3>What the file actually is</h3><p>When you run Claude Code in a project folder, it looks for a file called CLAUDE.md at the root. If it finds one, it reads the whole thing before touching your code.</p><p>Treat it like a system prompt that lives with your project. Every session starts with Claude already knowing your stack, your conventions, your hard rules, and what you are working on this week.</p><p>One file. Permanent context. No repeated setup.</p><h3>Where the file lives</h3><p>Claude Code checks three locations:</p><ol><li>Project root. The main one. Read at the start of every session in that folder.</li><li>Subdirectories. Useful for monorepos. Claude reads the one closest to where you are working.</li><li>Home directory. A global ~/.claude/CLAUDE.md that applies to every project.</li></ol><p>Start with the project root. Add a global one later once you know which preferences never change.</p><h3>The sections that matter</h3><p>Each section below has a specific job. Skip a section, and Claude fills the gap with its own defaults.</p><h3>1. Project overview</h3><p>Two or three sentences. What the project is, who it is for, what matters most.</p><pre>## Project Overview</pre><pre>This is a crypto signal bot dashboard built with Next.js and Tailwind.<br>It scans 98 trading pairs every 58 seconds using RSI, MACD, and Bollinger Bands<br>and displays live signals in a dark-mode UI.</pre><pre>The target user is a retail crypto trader who wants clean, fast signals<br>without noise. Speed and clarity are the two non-negotiable priorities.</pre><p>Now Claude filters every decision through the domain and the priorities.</p><h3>2. Tech stack</h3><p>List everything. No abbreviations. No assumptions left on the table.</p><pre>## Tech Stack</pre><pre>- Framework: Next.js 14 (App Router)<br>- Styling: Tailwind CSS only — no CSS modules, no styled-components<br>- Language: TypeScript strict mode<br>- Database: Supabase (Postgres)<br>- Auth: Supabase Auth<br>- Deployment: Vercel<br>- Package manager: pnpm<br>- State: Zustand<br>- Charts: Recharts</pre><h3>3. Coding conventions</h3><p>This is where most files fall short. Say how you write code, not just what you write it with.</p><pre>## Coding Conventions</pre><pre>- Use named exports for all components — no default exports<br>- File names use kebab-case: signal-card.tsx, not SignalCard.tsx<br>- Component names use PascalCase<br>- All functions use arrow function syntax<br>- No var — only const and let<br>- Prefer early returns over nested conditionals<br>- Add JSDoc comments only for exported utility functions<br>- Never use any — always type explicitly<br>- Keep components under 150 lines — extract if larger<br>- Co-locate types with the file that uses them unless shared across 3+ files</pre><p>Write it once. Stop correcting it in every session.</p><h3>4. The never-do list</h3><p>Underrated and the most powerful section in the file.</p><pre>## Never Do This</pre><pre>- Never install a new package without asking me first<br>- Never rewrite a component I did not ask you to touch<br>- Never use useEffect for data fetching — use React Query<br>- Never add console.log statements to production code<br>- Never use inline styles<br>- Never suggest switching the framework or database<br>- Never add placeholder comments like &quot;// TODO: implement this&quot;<br>- Never use emojis in code comments<br>- Never wrap everything in a try/catch without telling me</pre><p>Claude is helpful by default. Sometimes too helpful. It refactors things you did not ask about. It adds error handling you did not want. A hard-stop list kills that behaviour.</p><h3>5. File structure</h3><p>Show Claude how the project is organized so it stops inventing new folders.</p><pre>## File Structure</pre><pre>src/<br>  app/              # Next.js App Router pages<br>  components/       # Shared UI components<br>    ui/             # Primitive components (buttons, inputs, etc.)<br>    features/       # Feature-specific components<br>  lib/              # Utility functions and helpers<br>  hooks/            # Custom React hooks<br>  stores/           # Zustand stores<br>  types/            # Shared TypeScript types<br>  styles/           # Global styles only</pre><pre>Do not create new top-level folders without asking.<br>Do not put components in /app — only pages and layouts go there.</pre><h3>6. Current goals</h3><p>The section most people forget. What you are actively building right now, and what is out of scope.</p><pre>## Current Sprint Goals</pre><pre>- Build the signal card component with RSI, MACD, and BB indicators<br>- Connect to Supabase real-time for live updates<br>- Add a filter bar to sort signals by strength and timeframe<br>- Optimize for mobile — the dashboard must be fully usable on phone</pre><pre>Not working on authentication this sprint. Do not suggest auth-related changes.</pre><p>Without this, Claude will happily solve problems you are not trying to solve.</p><h3>7. Context and constraints</h3><p>Past decisions, rejected approaches, and gotchas that save you from re-litigating them.</p><pre>## Important Context</pre><pre>- We already tried using Socket.io for real-time — it caused memory leaks on Vercel.<br>  We switched to Supabase real-time. Do not suggest Socket.io.<br>- The Binance API rate limit is 1200 requests per minute per IP.<br>  Always account for this when writing fetch logic.<br>- The bot currently runs on a $6/month VPS. Keep dependencies lean.<br>- This project started as a personal tool and is now a paid product.<br>  Code quality matters — this is not a throwaway script.</pre><h3>A full template</h3><p>Copy this, customize the fields, drop it in your project root.</p><pre># CLAUDE.md</pre><pre>## Project Overview</pre><pre>[Describe what the project does in 2 to 3 sentences. Who is it for? What problem does it solve?]</pre><pre>## Tech Stack</pre><pre>- Framework: [e.g. Next.js 14 App Router]<br>- Styling: [e.g. Tailwind CSS]<br>- Language: [e.g. TypeScript]<br>- Database: [e.g. Supabase]<br>- Auth: [e.g. Supabase Auth]<br>- Deployment: [e.g. Vercel]<br>- Package manager: [e.g. pnpm]<br>- State management: [e.g. Zustand]</pre><pre>## Coding Conventions</pre><pre>- [List your naming conventions]<br>- [List your syntax preferences]<br>- [List your component structure rules]<br>- [List your commenting rules]<br>- [List your typing rules]</pre><pre>## Never Do This</pre><pre>- Never install packages without asking<br>- Never rewrite files I did not ask you to touch<br>- [Add your specific restrictions]</pre><pre>## File Structure</pre><pre>[Paste your directory tree here and annotate each folder]</pre><pre>## Current Goals</pre><pre>[List what you are actively building this week or this sprint]<br>[List what is explicitly OUT OF SCOPE right now]</pre><pre>## Important Context</pre><pre>[Anything Claude needs to know about past decisions, constraints, or gotchas]</pre><pre>## Communication Style</pre><pre>- Be direct. Skip the preamble.<br>- If you are unsure about something, ask before writing code.<br>- When you make a change, tell me what you changed and why in one sentence.<br>- Flag anything that looks like a potential bug or architectural issue, even if I did not ask.</pre><h3>The global file</h3><p>After a few project-level files, patterns show up. Preferences you want everywhere. That is your global CLAUDE.md.</p><p>Create it:</p><pre>mkdir -p ~/.claude<br>touch ~/.claude/CLAUDE.md</pre><p>Then fill it with your defaults:</p><pre># Global CLAUDE.md — My Defaults</pre><pre>## My Defaults Across All Projects</pre><pre>- I prefer TypeScript over JavaScript always<br>- I use pnpm as my package manager<br>- I write arrow functions not function declarations<br>- I prefer explicit types over inferred ones in function signatures<br>- Keep responses concise — I do not need lengthy explanations unless I ask<br>- If something I asked for is technically possible but a bad idea, tell me first</pre><pre>## Communication Rules</pre><pre>- Do not start responses with &quot;Great question&quot; or &quot;Certainly&quot;<br>- Be direct and skip filler sentences<br>- When writing code, write the code first and explain after if needed<br>- Do not suggest I read documentation unless you cannot answer the question</pre><pre>## Things I Never Want</pre><pre>- Placeholder comments in code<br>- Console.log in any code I will deploy<br>- Unsolicited refactors of things I did not ask about<br>- Default exports in React components</pre><p>This layer runs under every project. Combined with the project-level file, you get two stacks of context at all times.</p><h3>Not just for code</h3><p>The same file structure works for writing, research, or any workflow where you want consistent behaviour.</p><pre># CLAUDE.md — Content Operations</pre><pre>## Project Overview</pre><pre>This folder contains my article pipeline.<br>I write about AI tools, crypto trading, and productivity for solo builders.<br>My audience is intermediate to advanced. They do not need hand-holding.</pre><pre>## Writing Style Rules</pre><pre>- Write in first person<br>- Use short punchy sentences<br>- Avoid the word &quot;utilize&quot; — use &quot;use&quot;<br>- Avoid &quot;leverage&quot; as a verb<br>- No em dashes<br>- No bullet points in articles unless it is a list that genuinely needs them<br>- Capitalization is used for emotional emphasis — LIKE THIS — not randomly<br>- Conversational but never casual to the point of being sloppy</pre><pre>## What I Never Want in My Articles</pre><pre>- Phrases like &quot;in today&#39;s fast-paced world&quot;<br>- Passive voice where active voice works<br>- Filler intros that take more than 2 sentences to get to the point<br>- Conclusions that just summarize what I already said</pre><pre>## Tone</pre><pre>Direct. Opinionated. Personal. Written like someone who has actually done the thing.<br>Not a tutorial robot. Not a corporate blog. A real person sharing what works.</pre><p>Now Claude writes in your voice from the first line.</p><h3>Mistakes that make the file useless</h3><p><strong>Vague rules.</strong> “Write clean code” leaves everything to interpretation. “Named exports, kebab-case filenames, no default exports” does not.</p><p><strong>Writing it once and never touching it again.</strong> The project evolves. The file should too. Update it at the end of each sprint when you make a decision worth remembering.</p><p><strong>Treating it as a to-do list.</strong> The bulk of the file is stable context. Goals belong in one dedicated section. The rest should hold steady for weeks.</p><p><strong>Skipping the never-do list.</strong> You already know what you hate. Writing it down is the cheapest productivity gain available.</p><p><strong>No global file.</strong> If you only use project-level files, you rewrite the same preferences every time. Twenty minutes on the global version pays back for years.</p><h3>The next level: slash commands</h3><p>Once the CLAUDE.md is solid, combine it with custom commands. Claude Code reads markdown files from .claude/commands/ and exposes each one as a slash command.</p><p>Create .claude/commands/new-component.md:</p><pre>Create a new React component with the following requirements:</pre><pre>- TypeScript functional component<br>- Named export only<br>- Tailwind for styling<br>- Props interface defined above the component<br>- Place in src/components/features/ unless I specify otherwise<br>- File name in kebab-case</pre><pre>Ask me for the component name and purpose before writing anything.</pre><p>Type /new-component and the spec is loaded.</p><p>CLAUDE.md handles the project-wide context. Slash commands handle task-specific workflows. Stacked together, Claude Code stops feeling like a prompting tool and starts feeling like someone who has been on the team for a while.</p><p>The developers getting the most out of it are not the ones writing clever prompts. They are the ones who spent 30 minutes writing the file that does the prompting for them.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=1fe94d0a30d9" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[OpenClaw Full Setup Process. After Anthropic Access Cut. April 2026]]></title>
            <link>https://medium.com/@boredhead/openclaw-full-setup-process-after-anthropic-access-cut-april-2026-37a859f06bad?source=rss-f3b18b8c91bd------2</link>
            <guid isPermaLink="false">https://medium.com/p/37a859f06bad</guid>
            <category><![CDATA[openclaw]]></category>
            <category><![CDATA[openclaw-tutorial]]></category>
            <category><![CDATA[openclaw-setup]]></category>
            <dc:creator><![CDATA[boredhead]]></dc:creator>
            <pubDate>Thu, 16 Apr 2026 15:06:06 GMT</pubDate>
            <atom:updated>2026-04-16T15:06:06.061Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*Hu2EUpDifoc8pOco.png" /><figcaption>OpenClaw</figcaption></figure><p>OpenClaw’s install process changed. Anthropic cut subscription access for third-party tools. New models dropped. The whole landscape shifted in about two months. So this is the updated version everything I know from running OpenClaw. The right way to build it from scratch, the practices nobody bothers to document, and the stuff every other guide skips.</p><h3>Pre-installation checklist</h3><p>You need three things ready before you touch a terminal.</p><p><strong>1. An AI model application programming interface key</strong></p><p>OpenClaw works with multiple model providers. You’re not locked to one.</p><p>Here’s what’s available right now:</p><p><strong>Anthropic (Claude)</strong> my pick. The best overall for agent work. Opus 4.6 is the smartest model available and what I recommend for setup. Sonnet 4.6 is cheaper and handles everyday tasks well. <a href="http://console.anthropic.com/">console.anthropic.com</a></p><p><strong>Google (Gemini 2.5 Pro)</strong> good for long-context tasks. Has a generous free tier worth using if your budget is tight or you want a backup. <a href="http://aistudio.google.com/">aistudio.google.com</a></p><p><strong>Ollama (local models)</strong> run Gemma 4 or other open source models directly on your machine. Completely free. Not frontier quality, but handles routine agent tasks without issue.</p><p><strong>DeepSeek</strong> strong reasoning model with competitive pricing. Worth considering as a cheaper alternative to Opus for complex tasks.</p><p><strong>2. A Groq application programming interface key (for voice notes)</strong></p><p>This is separate from your main model key. Groq powers voice note transcription through the Whisper plugin — it’s how your agent understands voice messages on Telegram. You’ll use this constantly. It’s free. Sign up at <a href="http://console.groq.com/">console.groq.com</a> and grab your key.</p><p><strong>3. A web search application programming interface key</strong></p><p>Your agent needs to search the internet. Your options:</p><p><strong>Brave Search</strong> — roughly $5/month. Reliable, fast, best value. My recommendation. <a href="http://brave.com/search/api">brave.com/search/api</a></p><p><strong>Firecrawl</strong> search plus full page scraping in one tool. <a href="http://firecrawl.dev/">firecrawl.dev</a></p><p>Go with Brave Search. It’s been the most reliable in my experience.</p><h3>Installing OpenClaw</h3><p>Open terminal and run:</p><p><strong>On Windows (PowerShell):</strong></p><pre>iwr -useb https://openclaw.ai/install.ps1 | iex</pre><p>If you’re on a new Mac, you may need Homebrew first:</p><pre>/bin/bash -c &quot;$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/HEAD/install.sh)&quot;</pre><p>Once OpenClaw is installed, run the setup wizard:</p><pre>openclaw onboard</pre><p>This walks you through everything step by step. Here’s what to pick:</p><p><strong>Provider:</strong> Select Anthropic and paste your application programming interface key.</p><p><strong>Model:</strong> Select Opus 4.6. You want the smartest model available while you’re building the foundations.</p><p><strong>Communications:</strong> You’ll be prompted to set up a messaging platform. This guide uses Telegram. You can skip this step and do it manually later — I find it easier to handle the Telegram pairing as its own step.</p><p><strong>Skills to preload:</strong> Most guides say “install ClaWHub and move on.” Don’t do that. Install these:</p><ul><li><strong>ClaWHub</strong> — the skill marketplace</li><li><strong>MCPorter</strong> — Model Context Protocol tool routing</li><li><strong>OpenAI Whisper</strong> — voice transcription, essential for voice notes</li><li><strong>model-usage</strong> — track what your agent is spending</li><li><strong>GitHub</strong> — get this in now if you use Git at all</li><li><strong>nano-PDF</strong> — PDF reading and processing</li></ul><p>Skip Notion, ElevenLabs, and any other additional application programming interface prompts. You don’t need them yet.</p><p><strong>Hooks — enable all four:</strong></p><ul><li><strong>boot-md</strong> — loads your config files on startup</li><li><strong>bootstrap extra files</strong> — sets up your workspace structure</li><li><strong>command-logger</strong> — tracks what your agent runs</li><li><strong>session-memory</strong> — remembers context across sessions</li></ul><p>Once you get through these steps, you’ll see the option to hatch in the terminal user interface. This is the moment your agent comes alive in the terminal chat window. Do it.</p><p>Say hello. Give it a name. Watch it respond.</p><p>That first reply is a proper magic moment.</p><h3>Connecting Telegram</h3><p>You’ve got a working agent in the terminal. Now you want it on your phone.</p><p>Tell your agent exactly this:</p><blockquote><em>“okay [agent name], we’re going to use telegram to finish setting up and onboarding. next i will send you the API key for my telegram bot and you can install the telegram communication skill for me using it.”</em></blockquote><p>Then set up the bot:</p><ol><li>Open Telegram and message @BotFather</li><li>Send /newbot</li><li>Pick a name and username for your bot</li><li>BotFather gives you an application programming interface key — copy it</li><li>Go back to your agent in the terminal user interface and paste the key in with the message above</li></ol><p>Your agent will install the Telegram plugin for you.</p><p>Once it’s done, open your new bot in Telegram and click Start. You’ll see a PAIR code. Copy it and paste it back to your agent in the terminal user interface. It handles the rest — pairing, syncing, connecting everything.</p><p>Go back to Telegram and send “hi.”</p><p>Watch your agent reply.</p><p>This is how I run everything now.</p><h3>Setting up your agent properly from the start</h3><p>Now that Telegram is connected, run through this setup in order.</p><p><strong>1. Install Kickstart</strong></p><p>I built a skill called Kickstart that saves the first four hours of pain in OpenClaw. It’s free on ClaWHub.</p><p>Tell your agent:</p><blockquote><em>install the kickstart skill</em></blockquote><blockquote>Here’s what it gives you:</blockquote><ul><li><strong>SOUL.md</strong> — your agent’s personality file. Who it is, how it talks, what it cares about. Without this, your agent sounds like every other generic chatbot.</li><li><strong>USER.md</strong> — information about you. Name, timezone, preferences, platforms you use. Your agent reads this so it knows who it’s helping.</li><li><strong>AGENTS.md</strong> — the operating manual. Rules for how your agent behaves, when to speak, when to stay quiet, how to handle memory.</li><li><strong>TOOLS.md</strong> — local notes about your specific setup. Camera names, application programming interface details, device info — anything unique to your environment.</li><li><strong>HEARTBEAT.md</strong> — a checklist your agent reviews periodically to stay proactive instead of just waiting for input.</li></ul><p>Kickstart doesn’t just create these files. It guides your agent through filling them out properly. Install it, then move to the next step.</p><p><strong>2. Install QMD</strong></p><p>Tell your agent:</p><blockquote><em>install the QMD skill from clawhub</em></blockquote><p>QMD upgrades your agent’s memory system with semantic search. Instead of scanning flat text files trying to locate something you said three weeks ago, your agent can search by meaning. “What did I say about the budget?” just works.</p><p>Without QMD, your agent’s memory is a filing cabinet with no index. With it, everything is searchable.</p><p><strong>3. Your onboarding session</strong></p><p>This is the step that makes the biggest difference. I recommend this for everyone — from first-time users to the companies I’ve consulted for on OpenClaw systems.</p><p>Send your agent this:</p><blockquote><em>before we do anything else, i need you to understand who i am and what we’re building together. create a questionnaire — no more than 20 direct questions — covering who i am, what i do, how i work, what i need from you, and what your role is going to be. keep the questions short and clear. i’m going to answer all of them in one voice note so make sure they flow naturally as a conversation. after i reply, write everything you learn into your memory files so you never have to ask again.</em></blockquote><p>Your agent will come back with a list of questions.</p><p>Reply with a voice note. Not text. Voice.</p><p>Talk off the cuff. Be casual. Pause when you need to think. Your agent picks up on how you communicate, what you care about, and what’s actually on your mind. If you’re not sure what you want to use the agent for yet, say that. Talk through ideas like you’re thinking out loud. There’s no wrong answer here as long as you’re giving it real context.</p><p>One voice note gives your agent more useful information than weeks of typed messages. I learned that the hard way.</p><h3>Best practices from daily use</h3><p><strong>Route by model, not by habit</strong></p><p>Don’t run everything on Opus. It’s the best model, but you don’t need the best model for every task. Configure Opus for complex reasoning, multi-step tasks, and creative work. Route Sonnet or Groq for routine tasks — calendar checks, simple lookups, monitoring, notifications.</p><p>This alone cut my monthly cost in half. Once it’s configured, your agent routes automatically.</p><p><strong>Keep CLAUDE.md short</strong></p><p>This file gets re-injected every single message your agent processes. The leaked Claude Code source confirmed it. If yours is 2,000 words of life story, you’re burning tokens and confusing your agent on repeat.</p><p>Mine is 6 lines. Name, role, communication style, three rules. Everything else lives in skills and memory files where the agent pulls it when it actually needs it.</p><p><strong>Split agents by job</strong></p><p>If you’re running more than three or four different workflows, use separate agents. One agent scanning Twitter, managing data, writing content, handling emails, and running scheduled jobs works for about two weeks. Then context starts bleeding between tasks and everything slows down.</p><p>Dedicated agents for dedicated jobs. Cleaner context, faster responses, fewer mistakes.</p><p><strong>Read your memory files</strong></p><p>Your agent writes notes about you after every conversation. Check them weekly. You’ll catch wrong assumptions before your agent acts on them. Sometimes the notes are spot on. Sometimes they’re hilariously wrong. Either way, you want to know.</p><p><strong>Update regularly</strong></p><p>Nine common vulnerabilities and exposures dropped for OpenClaw in one week last month. One scored 9.9 out of 10. Run openclaw update weekly. Not optional.</p><p>If This Setup is Overhead, install <a href="https://startclaw.com/?atp=amyFKM"><strong>StartClaw </strong></a>— A fully managed hosting option for OpenClaw that handles the infrastructure side, keeps you on the updated version &amp; probably won’t let any malicious party disturb it. worth looking at if the setup overhead is what’s been holding you back.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=37a859f06bad" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Claude Code: Zero to Advance. Full Guide]]></title>
            <link>https://medium.com/@boredhead/claude-code-zero-to-advance-full-guide-d4031a5efdda?source=rss-f3b18b8c91bd------2</link>
            <guid isPermaLink="false">https://medium.com/p/d4031a5efdda</guid>
            <category><![CDATA[claude-code]]></category>
            <category><![CDATA[claude]]></category>
            <dc:creator><![CDATA[boredhead]]></dc:creator>
            <pubDate>Sun, 12 Apr 2026 18:07:10 GMT</pubDate>
            <atom:updated>2026-04-12T18:07:10.503Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*AqZ0OTii4AX-Z0HVcyEYEw.png" /></figure><p>Claude Code is not a chatbot. It’s an agent with access to your computer. It reads, creates, modifies, and deletes files. Searches the web. Runs terminal commands.</p><p>You say “create a folder” and it creates one.</p><pre>❯ claude<br>╭─────────────────────────────────╮<br>│  Claude Code v1.0.80            │<br>╰─────────────────────────────────╯</pre><pre>❯ Create a Chrome extension with a checklist<br>  based on @course.md</pre><pre>⠋ Thinking it through...</pre><pre>  ✓ Read: course.md (2.4KB)<br>  ✓ Created: manifest.json<br>  ✓ Created: sidepanel.html<br>  ✓ Created: styles.css<br>  ✓ Created: app.js</pre><pre>✓ Done · 18.5K tokens · 2% context</pre><p>Most people use it like a slow ChatGPT and then complain that AI doesn’t work. The issue is almost always setup and process.</p><p><strong>Two ways to work</strong></p><p>IDE extension (VS Code / Windsurf / Cursor) — better UI, fewer features.</p><p>Terminal — more capabilities, status line, voice input, split screen for parallel sessions. Recommended. I use Warp or iTerm2.</p><p><strong>First things after install</strong></p><p>Create an alias to bypass permission prompts:</p><pre>alias claude=&#39;claude --dangerously-skip-permissions&#39;</pre><p>Sounds alarming. In practice, six-plus months in, zero problems. Add it to your shell config alongside a couple of shortcuts:</p><pre># ~/.zshrc</pre><pre># ── Claude Code ──────────────────<br>alias claude=&#39;claude --dangerously-skip-permissions&#39;</pre><pre># ── shortcuts ────────────────────<br>alias cc=&#39;claude&#39;<br>alias ccr=&#39;claude --resume&#39;</pre><pre>❯ source ~/.zshrc<br>❯ claude<br>⚠ Bypass permissions enabled<br>✓ Ready. No confirmations.</pre><p>Install Whisper Flow or Aqua Voice. Speaking prompts is faster than typing them. You’re leaving roughly 40% of your speed on the table if you’re still typing everything by hand.</p><p><strong>Pricing</strong></p><ul><li>Pro ($20/month) — good starting point</li><li>Max 5x ($100/month) — enough for most people</li><li>Max 20x ($200/month) — multiple projects and agent teams</li></ul><p>Start with Pro. Hit limits, upgrade to 5x. They prorate the difference.</p><p>The same workload through the application programming interface runs around $500/month. The $100 subscription is a real saving.</p><p><strong>CLAUDE.md — the thing 90% of people skip</strong></p><p>Every new session starts with a blank slate. Without CLAUDE.md, the agent scans your project from scratch each time.</p><pre># Without CLAUDE.md:<br>❯ claude<br>  Scanning project structure...<br>  Reading package.json...<br>  Reading tsconfig.json...<br>  Analyzing 47 files...</pre><pre>  Tokens: 33K used just to understand the project<br>  Your messages: 0</pre><pre># With CLAUDE.md:<br>❯ claude<br>  Loaded CLAUDE.md (86 lines)<br>  Ready.</pre><pre>  Tokens: 1.2K<br>  Your messages: 0</pre><pre>  → 27x cheaper on every session start</pre><p>Fix: run /init. It creates a CLAUDE.md describing your project. Next session starts with context.</p><pre>❯ /init</pre><pre>⠋ Analyzing project structure...</pre><pre>Created: CLAUDE.md</pre><pre>  # My Project<br>  ## Overview<br>  Chrome extension - markdown to checklist<br>  ## Architecture<br>  ├── chrome-extension/<br>  │   ├── manifest.json<br>  │   ├── sidepanel.html<br>  │   └── app.js<br>  ├── landing/<br>  └── CLAUDE.md<br>  ## Rules<br>  - Always update extension version on changes<br>  - Use conventional commits</pre><pre>✓ CLAUDE.md saved · 86 lines</pre><p>Rule: CLAUDE.md is what the agent must know every session. Keep it under 500 lines. Longer means you’re doing something wrong.</p><p>Auto Memory exists too. I don’t rely on it. Stored at user/project level, can’t share with your team, hard to control. Put the important things explicitly in CLAUDE.md and let Auto Memory run in the background.</p><p><strong>Model Context Protocol (MCP) — and why most people use it wrong</strong></p><p>Model Context Protocol servers give the agent descriptions of application programming interface endpoints it can call. Install Chrome DevTools Model Context Protocol and the agent can open tabs, take screenshots, click elements.</p><pre># Install globally (needed everywhere):<br>❯ claude mcp add chrome-devtools \<br>    --scope user \<br>    npx @anthropic/chrome-devtools-mcp</pre><pre># Install per project (not needed everywhere):<br>❯ claude mcp add supabase \<br>    --scope project \<br>    npx supabase-mcp</pre><pre># Verify:<br>❯ /mcp<br>  chrome-devtools  ✓ connected (user)<br>  exa-search       ✓ connected (user)<br>  supabase         ✓ connected (project)</pre><p>Install globally only what you need in every project (Exa, Chrome DevTools). Everything else goes per-project.</p><p>Common mistake: installing 15 Model Context Protocol servers globally and wondering why context runs out on the third message.</p><p>But Model Context Protocol has a real problem. It loads all endpoints into context, runs fixed scenarios you can’t customize, and burns tokens on data you didn’t ask for. You want one task from a tracker and it fetches everything.</p><p>The fix is Skills.</p><p><strong>Skills — most people never get here</strong></p><p>A skill is a folder with instructions and helper files. Only the header (name and description) goes into context. It’s triggered by description and loaded on demand.</p><pre># MCP (old approach):<br>  → All endpoints loaded into context<br>  → Fixed scenarios<br>  → Can&#39;t customize<br>  → 5.7K+ tokens per MCP</pre><pre># Skills (new approach):<br>  → Only header in context (~50 tokens)<br>  → Loaded on demand<br>  → Editable and combinable<br>  → Any API = skill without MCP</pre><pre># Example:<br>❯ Create a landing page for the app</pre><pre>  Loaded skill: Landing Page Creator<br>  Loaded skill: Frontend Design<br>  Combined: 2 skills · 0.3K tokens</pre><pre>  vs MCP: 11.4K tokens to load same tools</pre><p>Where to find them: skills.sh is a marketplace with 100-plus ready solutions.</p><p>Skills can be combined. Landing Creator and Frontend Design together produce a landing page with real visual polish.</p><p><strong>Creating your own skills:</strong></p><ol><li>Install Skill Creator (available in the official marketplace)</li><li>Describe what you need: “create a skill for generating landing pages from a reference image”</li><li>Iterate — the first pass won’t be perfect</li></ol><p>Any application programming interface with documentation can become a skill. No Model Context Protocol needed. If a tool has a Skill and command-line interface option, use it instead of Model Context Protocol.</p><p><strong>Subagents — what actually separates beginners from advanced users</strong></p><p>Two problems with a single main session: you can’t parallelize and context is finite.</p><p>Subagents fix both. They run in isolated context windows, execute in parallel, and return results to the orchestrator.</p><pre># Without subagents (sequential):<br>  Landing v1  ████████░░  5 min · 100K tokens<br>  Landing v2  ████████░░  5 min · 100K tokens<br>  Landing v3  ████████░░  5 min · 100K tokens<br>  ─────────────────────────────────────<br>  Total:      15 min · 300K tokens<br>  Main ctx:   300K (overflowed ☠)</pre><pre># With subagents (parallel):<br>  Sub 1 → v1  ████████░░  5 min · 100K (isolated)<br>  Sub 2 → v2  ████████░░  5 min · 100K (isolated)<br>  Sub 3 → v3  ████████░░  5 min · 100K (isolated)<br>  ─────────────────────────────────────<br>  Total:      5 min · 50K in main context<br>  Main ctx:   50K ✓ clean</pre><p>3x faster. 6x less context in the main session.</p><p>Two ways to launch subagents:</p><ul><li>On the fly: “spin up two subagents for two design versions”</li><li>Pre-defined: file in .claude/agents/</li></ul><p>Pre-defined gives you control over the result.</p><p>You can set the model per subagent:</p><ul><li>Opus for plans</li><li>Sonnet for code</li><li>Haiku for search</li></ul><pre># .claude/agents/landing-creator.md</pre><pre>---<br>name: landing-creator<br>model: sonnet<br>color: yellow<br>skills:<br>  - landing-page<br>  - frontend-design<br>---</pre><p><strong>Agent Teams</strong> are a step up. Each teammate is a full Claude session with a shared task list. They can communicate with each other and you can address each one directly.</p><p>Don’t use Agent Teams for writing code as a beginner. You get organized chaos. Use them for multi-perspective research, competing hypotheses, and idea discussion where different viewpoints add real value.</p><p><strong>Context — the most important concept</strong></p><p>The context window is your budget. Everything goes in: tools, CLAUDE.md, Model Context Protocol, skills, your conversation history.</p><pre>Zones:<br>0-50%  - effective work<br>50-70% - be careful<br>70-85% - problems ahead<br>85%+   - auto-compact (context loss)</pre><pre>Context: ██████████████████████░░░░░░░░░  67%</pre><pre> 0%━━━━━━50%━━━━━━70%━━━━━━85%━━━100%</pre><pre># Your status line:<br>❯ ~/my-project · opus-4 · 1M ctx · 67% ■■■■■■░░</pre><p>Install the status line. If you can’t see that percentage in real time, you’re working blind.</p><p>Three rules that save hundreds of dollars:</p><ol><li>Keep CLAUDE.md under 500 lines. Only necessary Model Context Protocol servers and skills. No contradictions.</li><li>One task, one session. Task done, run /clear, start fresh.</li><li>Install tools per-project, not globally. Global is for what you need in every single project.</li></ol><p>Break one and you lose context, money, and patience.</p><p><strong>Model selection</strong></p><ul><li>Opus: planning, complex decisions, orchestration</li><li>Sonnet: writing code (with a good plan in place)</li><li>Haiku: searching documentation</li></ul><p>Writing code on Opus without a plan is like driving a Ferrari on a dirt road. The power is there, the results aren’t.</p><p>If you’re hitting limits, use Opus for planning and Sonnet for implementation inside subagents.</p><p><strong>Deploy</strong></p><p>Frontend: Vercel. npx vercel, authenticate, deploy. Done.</p><pre>❯ npx vercel<br>  ? Set up and deploy? Yes<br>  ? Which scope? my-team<br>  ? Link to existing project? No<br>  ? What&#39;s your project&#39;s name? my-app<br>  ? In which directory is your code? ./landing</pre><pre>  🔗 <a href="https://my-app.vercel.app/">https://my-app.vercel.app</a></pre><pre>  ✓ Production deployed</pre><p>Backend: Railway, Supabase, Directus.</p><p>If you’re building a public service with user data, think through backups, endpoint permissions, and legal exposure before you ship. You can validate a hypothesis in an hour. A leaked user database takes much longer to recover from.</p><p><strong>Git</strong></p><p>No Git means no save points. Good luck rebuilding from scratch.</p><pre>❯ git init<br>❯ git add .<br>❯ git commit -m &quot;feat: initial chrome extension&quot;</pre><pre># Branches:<br>❯ git checkout -b feature/landing-v2<br>  Switched to new branch &#39;feature/landing-v2&#39;</pre><pre># Worktree (parallel work):<br>❯ git worktree add ./worktrees/v2 feature/landing-v2<br>❯ git worktree add ./worktrees/v3 feature/landing-v3</pre><pre># Two Claudes simultaneously:<br>  [Terminal 1] ~/worktrees/v2 ❯ claude<br>  [Terminal 2] ~/worktrees/v3 ❯ claude</pre><pre>  → Don&#39;t interfere with each other</pre><p>Git Worktree creates a physical copy of your project in a separate folder. Two Claude sessions, different branches, no conflicts.</p><p>Keep repositories private. Search “github leaked api keys” if you think nobody cares about your project.</p><pre># ✗ WRONG (secrets in code):<br>  .env<br>  ├── OPENAI_KEY=sk-proj-abc123...<br>  ├── VERCEL_TOKEN=vrl_def456...<br>  └── DB_PASSWORD=supersecret</pre><pre># ✓ RIGHT (secrets in GitHub):<br>  Settings → Secrets → Actions<br>  ├── OPENAI_KEY      ••••••••<br>  ├── VERCEL_TOKEN    ••••••••<br>  └── DB_PASSWORD     ••••••••</pre><pre>  → Local: test keys only<br>  → Production: CI/CD only</pre><p>Production keys on your local machine are not a question of “if they leak.” Store secrets in GitHub Secrets and access them only through continuous integration/continuous deployment.</p><p><strong>Process — the part that actually matters</strong></p><p>DORA 2025: strong teams with AI get stronger, weak teams discover more problems faster. The biggest return on investment comes from process quality, not tool selection.</p><p>Without process, you’re automating chaos.</p><p>Minimum viable process: Planning, plan review, decomposition, implementation via subagents, code review.</p><pre># Without process:<br>  ❯ Build me an app<br>  ... 300K tokens later ...<br>  ✗ Context overflow<br>  ✗ Code doesn&#39;t work<br>  ✗ Start over</pre><pre># With process:<br>  ❯ Brainstorm<br>  ❯ Specification<br>  ❯ Plan<br>  ❯ Subagent-driven implementation<br>  ❯ Code review</pre><pre>  Result:<br>  ├── 9 tasks completed<br>  ├── 9% context used<br>  ├── Tests passing<br>  └── Pull request ready to merge</pre><p>9 tasks, 9% context. Someone running the same work without this process hits 85% on one task. The difference isn’t the model.</p><p><strong>The path from zero to advanced</strong></p><ol><li>Understand it’s an agent, not a chatbot</li><li>Install, bypass permissions, add voice input</li><li>CLAUDE.md — context savings from session one</li><li>Model Context Protocol, then Skills, then Subagents, then Agent Teams</li><li>Understand context and monitor it in real time</li><li>One-click deploy</li><li>Git for safety and parallel work</li><li>Process: plan, decompose, implement, review</li></ol><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=d4031a5efdda" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Everything Claude Has Shipped in 2026: Full Reference]]></title>
            <link>https://medium.com/@boredhead/everything-claude-has-shipped-in-2026-full-reference-65341c1cea30?source=rss-f3b18b8c91bd------2</link>
            <guid isPermaLink="false">https://medium.com/p/65341c1cea30</guid>
            <category><![CDATA[anthropic-claude]]></category>
            <category><![CDATA[claude]]></category>
            <category><![CDATA[claude-code]]></category>
            <category><![CDATA[claude-cowork]]></category>
            <dc:creator><![CDATA[boredhead]]></dc:creator>
            <pubDate>Tue, 24 Mar 2026 17:17:58 GMT</pubDate>
            <atom:updated>2026-03-24T17:19:27.481Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*_jAjIjCUzPuw45AzpUOFQw.png" /><figcaption>Claude 2026 — whats new?</figcaption></figure><p>Here’s what Claude Code Shipped in 2026 with Full reference.</p><h3>The Models</h3><p><strong>Claude Opus 4.6</strong> launched February 5. 1 million token context window. Scores 78.3% on MRCR v2 at 1 million tokens, highest among frontier models at that length. Anthropic reports a 14.5 hour task completion window, longest in the frontier. Dominates benchmarks in legal, financial, and coding tasks. $5/$25 per million tokens on the application programming interface. 128K max output tokens. Supports adaptive thinking with a new “max” effort level.</p><p>Use Opus for complex analysis across large contexts, codebase refactoring, deep research, high-stakes deliverables, and serious content production. At $5/$25 per million tokens, a heavy Opus workflow can burn $50–100/day. Default to Sonnet and escalate to Opus only when Sonnet’s output isn’t good enough.</p><p><strong>Claude Sonnet 4.6</strong> launched February 17. 1 million token context window, generally available since March 13. Upgrades across coding, computer use, long context reasoning, agent planning, knowledge work, and design. Early testers preferred it over Sonnet 4.5 roughly 70% of the time. Users chose it over the previous flagship Opus 4.5 in 59% of cases. $3/$15 per million tokens. 64K max output. 30–50% faster than Sonnet 4.5. Default for Free and Pro plans on claude.ai.</p><p>Use Sonnet for everyday work, quick drafts, standard coding, and agent workflows where speed matters. It matches Opus on many office tasks at roughly 40% lower cost.</p><p><strong>Claude Haiku 4.5</strong> is fast and cheap, built for high-volume application programming interface pipelines and subagent assignments where you want a low-cost read-only worker. Important caveat: Haiku has zero prompt injection protection. If it’s processing untrusted input in agentic setups, read the docs carefully before deploying.</p><h3>The 1 Million Token Context Window at Standard Pricing</h3><p>Previously, requests over 200K tokens were billed at a premium ($10/$37.50 per million for Opus). As of March 13, that surcharge is gone. A 900K token request costs the same per-token rate as a 9K one. No multiplier, no fine print, no beta header required.</p><p>That’s roughly 750,000 words of context. Entire codebases. Full legal contracts. Massive datasets. Months of documentation, all held in working memory simultaneously. Media limits also jumped to 600 images or PDF pages per request, up 6x from 100. Available on Claude Platform, Microsoft Foundry, and Google Cloud Vertex AI.</p><p>Teams that previously had to chunk context and build summarization pipelines can now just load everything. One company reported that raising context from 200K to 500K actually reduced total token usage because the model spent less time re-reading and reprocessing earlier information.</p><h3>Which Mode to Use When</h3><p>Claude has four modes. Most people only know one.</p><p><strong>Chat</strong> is the browser and mobile interface. Good for quick questions, brainstorming, writing drafts. Every conversation starts blank.</p><p><strong>Cowork</strong> is the desktop agent. It reads and writes to your actual files, executes multi-step tasks autonomously, and delivers finished work to your folder. Use it when you want to delegate work, not have a conversation.</p><p><strong>Code</strong> runs in your terminal, sees your codebase, writes code, executes commands, manages git. If you write code, this is where the deepest capability lives.</p><p><strong>Projects</strong> are saved workspaces where you upload files and instructions once. Every new chat in that project starts with full context. Use them for recurring work where the context doesn’t change much between sessions.</p><p>Quick rule: Chat for quick questions. Cowork for real work on your files. Code for development. Projects for recurring work with stable context.</p><h3>Memory and Personalization</h3><p>As of March 24, 2026, memory from chat history is available to all users including the free tier. Claude remembers relevant context from your conversations and generates a memory summary that carries across sessions. You can view, edit, and delete memories in Settings &gt; Capabilities. Import and export your entire memory, which is useful for backing up before experimenting or transferring context to a new account. Incognito chats exclude specific conversations from memory.</p><p>Go to Settings &gt; Memory right now and read what Claude already remembers. Edit anything wrong or outdated. Add context it should know. The more accurate your memory profile, the less you repeat yourself across sessions.</p><p>Cowork sessions don’t carry memory between sessions. Your context files are the workaround.</p><h3>Claude Cowork</h3><p>Cowork launched January 12 as a research preview for Claude Max subscribers on macOS. Expanded to Pro on January 16, Team and Enterprise on January 23. Windows followed.</p><p>Stop thinking about it like a chat interface. Cowork is task delegation. You describe what “done” looks like. Claude makes a plan, breaks it into subtasks, executes autonomously on your actual computer, and delivers finished files to your folder.</p><p>Anthropic built Cowork in roughly 10 days using only Claude Code.</p><h4>The Setup</h4><p>The people struggling with Cowork are writing long, detailed prompts for every task and getting inconsistent results. The people who figured it out spent an afternoon building their context setup and now write 10-word prompts that produce client-ready deliverables.</p><p><strong>Step 1: Build your workspace folder.</strong></p><p>Create a dedicated folder for Cowork. Don’t point it at your entire Documents directory. If something goes wrong, you want the damage contained. Cowork has real read/write access to whatever folder you share.</p><pre>CLAUDE COWORK/<br>├── CONTEXT/        # Your identity and preferences (.md files)<br>├── PROJECTS/       # Active work, one subfolder per project<br>├── TEMPLATES/      # Proven structures to reuse as patterns<br>└── OUTPUTS/        # Where Cowork delivers finished work</pre><p>The folder names don’t matter. The separation does.</p><p><strong>Step 2: Create your context files.</strong></p><p>Create three markdown files in your CONTEXT folder.</p><p>about-me.md is who you are, what you do, your current priorities. Not your resume. What you actually work on day to day, who you serve, what matters right now. Include one or two examples of work you&#39;re proud of.</p><p>brand-voice.md is how you communicate. Tone descriptors, words you use, words you&#39;d never use, formatting preferences, and 2-3 paragraphs of your actual writing as a reference sample. This is what separates generic output from output that sounds like you.</p><p>working-preferences.md is how Claude should behave. Ask questions before starting. Show a plan before executing. Never delete files without confirmation. Default output formats. Quality standards. Things to avoid.</p><p>These three files eliminate the cold start problem. Without them, every session begins from zero. With them, Claude starts every session already knowing your voice, your standards, and your preferences.</p><p>The key insight most people miss: these files compound. Refine them weekly. Every time Claude produces something you don’t like, ask whether it’s a prompt problem or a context problem. Nine times out of ten, it’s context. Add one line to one file. Permanent fix.</p><p><strong>Step 3: Set Global Instructions.</strong></p><p>Go to Settings &gt; Cowork &gt; Edit Global Instructions.</p><p>Global Instructions load before everything else. Before your files. Before your prompt. Before Claude even looks at your folder. They’re the baseline behavior that applies to every session.</p><p>Starting template:</p><pre>I&#39;m [Name], [Role]. Before starting any task, read my context files <br>first. Always ask clarifying questions before executing. Show a brief <br>plan before taking action. Default output: .docx. Never delete files <br>without my explicit approval. If confidence is low, say so.</pre><p>This means even your most rushed prompt still produces calibrated output. Claude always knows who you are, always reads the right files first, always asks before guessing.</p><p><strong>Step 4: Learn AskUserQuestion.</strong></p><p>Instead of you engineering the perfect prompt, Claude engineers the questions. Add “Start by using AskUserQuestion” to any prompt and Cowork generates an interactive form with multiple choice questions, clickable options, and specific alternatives.</p><p>The universal prompt template that works for nearly everything:</p><pre>I want to [TASK] to [SUCCESS CRITERIA].</pre><pre>First, explore my CLAUDE COWORK folder. Then ask me questions <br>using AskUserQuestion. I want to refine the approach with you <br>before you execute.</pre><p>That template plus your context folder handles 80% of use cases.</p><h4>Every Feature Shipped for Cowork</h4><p><strong>Connectors</strong> shipped February 24. Cowork connects to Google Drive, Gmail, DocuSign, FactSet, Google Calendar, Slack, and more. Claude can autonomously navigate your Drive, pull documents, synthesize data across sources, draft emails based on what it finds, and flag issues in contracts.</p><p>Go to Settings &gt; Connectors. Browse the directory (50+ integrations). Click Add. Authenticate. Done. Connectors are free on all plans including the free tier and are probably the most underused feature in Cowork.</p><p>After connecting Slack:</p><pre>Search my Slack messages from the last 7 days and give me a summary <br>of anything I need to follow up on. Organize by urgency.</pre><p>After connecting Google Drive:</p><pre>Find the most recent document about [project name] in my Drive. <br>Read it and tell me the three most important things I need to know.</pre><p>After connecting Google Calendar:</p><pre>Look at my calendar for this week, identify any meeting conflicts, <br>and draft a reschedule email for the lowest priority one.</pre><p><strong>Plugins and Marketplace</strong> shipped February 24. Pre-built plugins for specific job functions. Each plugin bundles skills, slash commands, and connectors into role-specific packages. Official plugins cover Sales, Marketing, Legal, Finance, Data Analysis, Product Management, Customer Support, Enterprise Search, Engineering, Human Resources, Operations, Design, Brand Voice, Bio Research, and more.</p><p>Install from the Customize menu in the left sidebar &gt; Browse plugins. Type / in any chat to see available slash commands.</p><p>Plugins worth installing first:</p><p>Productivity handles tasks, calendars, and daily workflows. Type /productivity:start and Claude reviews your day.</p><p>Data Analysis lets you drop a CSV, type /data:explore, and Claude summarizes columns, flags anomalies, suggests analyses, and writes structured query language in plain English.</p><p>Then install one role-specific plugin that matches your work. /marketing:draft-content pulls your brand voice and drafts content. /sales:call-prep researches accounts and preps talking points. /legal:review reads contracts and flags risky clauses.</p><p>Teams can build private marketplaces to distribute custom plugins across their organization on Team and Enterprise plans. Build once. Deploy to hundreds.</p><p>After installing, tell Claude to “customize the [plugin-name] plugin for me based on my company.” Claude asks questions about your workflows, terminology, and preferences, then remembers the answers for every future session with that plugin.</p><p><strong>Scheduled Tasks</strong> shipped February 25. Tell Claude once to do something on a recurring basis. Morning email summaries. Friday metrics pulls. Weekly competitive intel briefings. It runs automatically as long as your computer is awake and Claude Desktop is open.</p><p>Example setup:</p><pre>Every Monday at 7am, research [competitor names] for news, product <br>updates, or pricing changes from the past 7 days. Check [industry <br>publications] for relevant coverage. Save a summary brief to <br>/competitive-intel/YYYY-MM-DD-weekly-brief.md. Flag anything that <br>directly impacts our positioning.</pre><p>Combined with connectors, scheduled tasks become genuinely autonomous:</p><pre>Every Monday, pull all unread Slack messages from #product-feedback, <br>categorize them by theme, and create a summary in Google Drive.</pre><p>The scheduled task runs. The connector pulls live data. Claude processes it. The output appears in your folder.</p><p><strong>Dispatch</strong> shipped March 17. The phone-to-desktop bridge. Available to Pro and Max subscribers. A persistent agent thread syncs across Claude Desktop and the Claude mobile app, letting you manage Cowork tasks from anywhere.</p><p>Setup: Open Claude Desktop &gt; Cowork &gt; click Dispatch in the left sidebar. Toggle “Keep awake” on (without it, Dispatch stops when your computer sleeps). Then open the Claude mobile app and tap Dispatch in the sidebar.</p><p>One continuous conversation that syncs across devices. Stack multiple tasks in one Dispatch message and Claude works through them sequentially while you’re away.</p><p>Key detail most people miss: the Dispatch orchestrator doesn’t read your CLAUDE.md. It formulates task prompts based on assumptions. Sub-tasks do read it, but the prompt already carries imprecise framing. Fix: include “read CLAUDE.md” in your Dispatch message.</p><p>You can’t add connectors from mobile. Set up Gmail, Slack, and Notion on desktop first. Dispatch inherits them all. You also can’t attach files from mobile yet. Workaround: email them to yourself and tell Dispatch to pull them via the Gmail connector.</p><p><strong>Projects</strong> shipped March 20. Organize related tasks into persistent workspaces with their own files, links, instructions, and memory. Import existing folders or start fresh. A project for “Q1 Financial Reports” and another for “Product Launch Materials” each maintain separate context. Projects turn Cowork from a one-off agent session into a persistent workspace, which matters for research-heavy work where you keep losing context across chats.</p><p><strong>Computer Use</strong> shipped March 23, research preview, macOS only, for Claude Pro and Max subscribers. Available in both Cowork and Claude Code. Claude can now point, click, and navigate your screen. It opens apps, uses the browser, fills in forms, and operates any tool on your computer. When there’s a direct connector, Claude uses that first. When there isn’t one, it uses your mouse and keyboard.</p><p>Claude asks for permission before taking significant actions. Anthropic recommends not using this for sensitive information as a precaution. The biggest risk: prompt injection through screen content. If Claude navigates to an untrusted site, the page content enters the context window and can influence Claude’s behavior. Stick to trusted applications and known sites.</p><p>Pair it with Dispatch and you can tell Claude from your phone to do something that requires navigating your desktop, your browser, or any application without a connector.</p><h4>Real Use Cases</h4><p><strong>Organize months of accumulated files.</strong> Point Cowork at a folder with 6 months of dumped files: receipts, contracts, notes, screenshots.</p><pre>Organize all files in this folder into subfolders by type (receipts, <br>contracts, notes, images). Use the format YYYY-MM-DD-descriptive-name <br>for all filenames. Create a summary log documenting every change. Don&#39;t <br>delete anything. If a file could belong to multiple categories, put it <br>in /needs-review.</pre><p>Claude reads every file, categorizes them, renames with dates, creates the structure, and gives you a log.</p><p><strong>Client deliverable from raw materials.</strong> You have meeting notes, a transcript, and some research links. You need a polished report.</p><pre>Using the files in /client-a/raw-materials, create a client-ready <br>report. Include executive summary, key findings, recommendations, and <br>next steps. Match the format of the template in /templates/. <br>Ask me questions first.</pre><p><strong>Weekly research brief on autopilot.</strong> Set up a scheduled task for competitive intelligence. Every Monday at 7am, Cowork researches competitors, checks industry publications, and saves a formatted brief. Combine with connectors to pull live data from Slack, Gmail, and Drive.</p><p><strong>Financial modeling.</strong> Ask Cowork to build a social media exit valuation model. It can plan itself, find formula errors, fix itself, and deliver a structured Excel file with formulas across multiple valuation methods: revenue multiples, earnings before interest/taxes/depreciation/amortization multiples, audience value, and a 5-year discounted cash flow model.</p><h4>Honest Limitations</h4><p><strong>Usage burns fast.</strong> A single complex session can consume what would normally be dozens of regular chat conversations. Community reports suggest heavy Cowork users hit rate limits in 3–4 days on Pro. Multi-step tasks with file reading, document creation, and parallel subtasks are compute-intensive. If Cowork becomes your main workflow, Max ($100/month for 5x Pro usage, or $200/month for 20x) is probably the right tier. Monitor Settings &gt; Usage before you get cut off mid-task.</p><p><strong>Context compaction will hit you on long sessions.</strong> When a session approaches its context limit, Claude automatically summarizes earlier parts of the conversation to make room. Numbers get rounded, specific file references get vague, decisions made early on get compressed into summaries. If Claude starts referencing “typical patterns” instead of specific files it read earlier, compaction already happened. For critical details, tell Claude to write key findings to a file you can reference later.</p><p><strong>It’s still a research preview.</strong> It can misread files. It sometimes takes an odd approach when a simpler one would work. Agents can go in a weird direction on complex multi-step tasks roughly 10% of the time. Review what it produces before sending anything to a client.</p><p><strong>No cross-session memory.</strong> Every new Cowork session starts completely fresh. Your context files are the workaround. Preferences live in files. Project plans live in documents. Standards live in instructions. If you want continuity, build it into files. The upside: a well-documented workflow is portable, shareable, and version-controlled.</p><p><strong>Tasks stop if you close the app.</strong> Cowork runs as an active session inside Claude Desktop. Close the window and the task stops. Put your computer to sleep instead.</p><p><strong>Desktop only.</strong> No mobile Cowork, no browser version. Build your context files in a cloud-synced folder (iCloud, Dropbox, OneDrive) so your files stay consistent across machines. Dispatch bridges the gap partially.</p><h3>Claude Code</h3><p>Claude Code started as a command-line coding tool in February 2025. It’s now a full extensible platform for orchestrating agents across your entire development workflow, pulling $2.5 billion in run-rate revenue.</p><p>Install via npm:</p><pre>npm install -g @anthropic-ai/claude-code</pre><p>Then cd into your project, type claude, and you&#39;re talking to an agent that can see your entire codebase and act on it. Read files, write files, run commands, search the web, execute tests, commit code. There&#39;s also a web version at claude.ai that got a major upgrade in February with multi-repo sessions, better diff and git status visualization, and slash commands. The terminal version is still where the deepest features live.</p><h4>CLAUDE.md: Your Project’s Instruction Manual</h4><p>When you start a session, the first thing Claude does is read your CLAUDE.md. It loads straight into the system prompt and stays in context for the entire conversation.</p><p>What to put in it: build, test, and lint commands (the actual bash commands). Key architectural decisions. Non-obvious gotchas. Import conventions, naming patterns, error handling styles. File and folder structure for the main modules.</p><p>What not to put in it: anything that belongs in a linter or formatter config. Full documentation you can already link to. Long paragraphs explaining theory. Keep it under 200 lines. Files longer than that start eating too much context and instruction adherence drops.</p><p>Tell it why, not just what. “Use TypeScript strict mode” is okay. “Use TypeScript strict mode because we’ve had production bugs from implicit any types” is better. The why gives Claude context for judgment calls you didn’t anticipate.</p><p>Update it constantly. Press # while working and Claude adds instructions to your CLAUDE.md automatically. Every time you correct Claude on the same thing twice, that&#39;s a signal it should be in the file.</p><p>Bad CLAUDE.md looks like documentation written for a new hire. Good CLAUDE.md looks like notes you’d leave yourself if you knew you’d have amnesia tomorrow.</p><h4>The CLAUDE.md Hierarchy</h4><p>There isn’t one CLAUDE.md. There are four layers that merge at session start:</p><p><strong>Managed Policy (org-wide):</strong> IT deployed. Cannot be overridden. Organization-wide rules.</p><p><strong>~/.claude/CLAUDE.md (global):</strong> Your personal preferences across all projects. Not version controlled.</p><p><strong>./CLAUDE.md (project root):</strong> Team instructions. Committed to git. Everyone who clones the repo gets these.</p><p><strong>CLAUDE.local.md (personal project overrides):</strong> Your personal tweaks for this specific project. Automatically gitignored.</p><p>Higher layers win on conflict.</p><p>The most common team issue: a developer puts instructions in their user-level config instead of the project-level file. They get perfect behavior. A new team member clones the repo, doesn’t have those user-level instructions, and gets inconsistent results. Everyone blames the model when the actual problem is configuration. Always put team standards in the project-level file.</p><h4>Rules Directory: Modular Instructions That Scale</h4><p>Once your CLAUDE.md gets crowded, split instructions into .claude/rules/ files. Every markdown file in this directory loads alongside your CLAUDE.md automatically.</p><pre>.claude/rules/<br>├── code-style.md<br>├── testing.md<br>├── api-conventions.md<br>└── security.md</pre><p>Each file stays focused. The person who owns application programming interface conventions edits api-conventions.md. Nobody steps on anyone else.</p><p>Path-scoped rules are where this pays off. Add YAML frontmatter with glob patterns and the rules only activate when Claude is working with matching files:</p><pre>---<br>paths:<br>  - &quot;**/*.test.tsx&quot;<br>---<br># Test Conventions<br>Use React Testing Library, not Enzyme. Test behavior, not implementation.<br>Always include at least one integration test per component.<br>Mock API calls with MSW, never with jest.mock on fetch.</pre><p>This catches every test file regardless of directory. Directory-level CLAUDE.md files only apply to files in that one directory. For conventions that must apply across 50+ directories of test files, path-specific rules are the correct approach. They also reduce token usage because they only load when relevant.</p><h4>Commands vs Skills vs Agents</h4><p><strong>Commands</strong> (.claude/commands/) are slash commands you trigger manually. A file named review.md becomes /project:review. The ! backtick syntax runs shell commands and embeds output before Claude sees the prompt.</p><pre>---<br>description: Review current branch diff before merging<br>---<br>## Changes to Review<br>!`git diff --name-only main...HEAD`</pre><pre>## Detailed Diff<br>!`git diff main...HEAD`</pre><pre>Review for code quality, security vulnerabilities, missing tests, <br>and performance concerns. Give specific, actionable feedback per file.</pre><p>Now /project:review injects the real git diff into the prompt automatically. Use $ARGUMENTS to pass parameters: /project:fix-issue 234 feeds issue 234&#39;s content directly in.</p><p>Project commands (.claude/commands/) are committed and shared. Personal commands (~/.claude/commands/) show up as /user:command-name.</p><p><strong>Skills</strong> (.claude/skills/) are workflows Claude invokes on its own when the task matches. You don&#39;t type a slash command. Claude reads the skill&#39;s description, recognizes the current task matches, and activates automatically. Commands wait for you. Skills watch for the right moment and act on their own.</p><p>Skills are folders, not single files. They can include scripts, reference docs, data, templates. A SKILL.md with YAML frontmatter defines the trigger:</p><pre>---<br>name: security-review<br>description: Comprehensive security audit. Use when reviewing code for <br>  vulnerabilities, before deployments, or when the user mentions security.<br>allowed-tools: Read, Grep, Glob<br>---</pre><p>Skills support effort frontmatter, letting you override the model’s thinking effort level when invoked. They also support on-demand hooks that only activate when the skill is called.</p><p>Anthropic’s own engineering team uses hundreds of skills internally across nine categories: library and application programming interface reference, product verification, data fetching, business process automation, code scaffolding, code quality review, continuous integration and deployment, runbooks, and infrastructure operations. On March 7, they open-sourced 17 of these at anthropics/skills on GitHub. The highest-value content in any skill is the gotchas section. Build it from the stuff that burned you.</p><p><strong>Agents</strong> (.claude/agents/) are specialized subagent personas with their own system prompts, tool access, and model preferences.</p><pre>---<br>name: code-reviewer<br>description: Expert code reviewer. Use PROACTIVELY when reviewing PRs.<br>model: sonnet<br>tools: Read, Grep, Glob<br>---<br>You are a senior code reviewer focused on correctness and maintainability.<br>Flag bugs, not just style issues. Suggest specific fixes.</pre><p>The tools field restricts what the agent can do. A security auditor only gets Read, Grep, and Glob. No write access. The model field lets you use cheaper models for focused tasks. Haiku handles most read-only exploration well.</p><p>Subagents keep your main context clean. The main agent’s context window fills up with exploration. Subagents do the messy work in isolated context and return compressed findings. Your main conversation only gets the answer.</p><h4>Tasks</h4><p>Shipped January 22. The old Todos system was upgraded into Tasks, a proper project management primitive. Tasks have dependencies, are stored in the filesystem (~/.claude/tasks), and multiple subagents or sessions can collaborate on the same task list. When one session updates a task, the change broadcasts to all sessions working on that list. Set a task list as an environment variable and spin up parallel agents that coordinate through it.</p><h4>Agent Teams</h4><p>Shipped February 5 alongside Opus 4.6 as an experimental feature. Where subagents are isolated workers reporting back to a coordinator, Agent Teams are a collaborative group. Teammates message each other directly through an inbox-based system, divide work through a shared task list with dependency tracking, and coordinate in parallel. Up to 10 simultaneous teammates.</p><p>Enable with CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS=1 in settings.json.</p><p>Where this actually shines: a feature that touches the application programming interface, the frontend, and the test suite. Spin up three teammates. One handles the application programming interface endpoint. One builds the React component. One writes the integration tests. They coordinate through the shared task list. All three work in parallel instead of sequentially. A task that takes one session 90 minutes finishes in 30.</p><p>Agent Teams add coordination overhead and consume significantly more tokens than a single session. Use them when parallel exploration adds real value and teammates can operate independently. For sequential tasks or same-file edits, stick to single sessions or subagents.</p><h4>Remote Control</h4><p>Shipped February 24 for Max users, later expanded to Pro. Run claude rc in your terminal, then open the Claude mobile app or claude.ai on another device to continue controlling that session remotely. Channels superseded this for most use cases by adding Telegram and Discord as interfaces, but Remote Control is still the simplest way to get phone-to-terminal access without setting up a messaging bot.</p><h4>Claude Code Channels</h4><p>Shipped March 20 as a research preview. Channels hooks up a running Claude Code session to Telegram or Discord. Send a message from your phone. Claude processes it using your full local development environment (files, tools, git, everything). Replies through the same messaging app. Your session sits in the background. Events come in from the outside world. Claude handles each one with full project context.</p><p>This is the same interaction model that made OpenClaw go viral after its November 2025 release, except Channels is native to Claude Code, backed by Anthropic’s safety infrastructure, and built on the Model Context Protocol, so the architecture is extensible.</p><p>Setup:</p><pre># Install the Telegram plugin<br>/plugin install telegram@claude-plugins-official</pre><pre># Configure with your bot token (from BotFather)<br>/telegram:configure &lt;YOUR_BOT_TOKEN&gt;</pre><pre># Start with channels flag<br>claude --channels plugin:telegram@claude-plugins-official</pre><p>Open Telegram, send any message to your bot. It replies with a pairing code. Use /telegram:access pair &lt;code&gt; to complete the link. The pairing locks the bot to your specific user ID so nobody else can control your session.</p><p>Discord follows the same pattern with its own plugin.</p><p>Current limitations: you need to keep a terminal session open (combine with tmux, screen, or a background process). Only Anthropic-approved plugins during the research preview. Permission approvals still require terminal access. The docs for building custom channels are already public.</p><h4>Hooks</h4><p>Shell commands that fire automatically at specific lifecycle events: pre-commit, post-tool-call, when Claude tries to edit certain files. These are about deterministic control, not model intelligence.</p><p>Auto-lint every file Claude writes. Block sensitive files from being committed. Send a Slack notification when Claude finishes. Run type-checking after every edit. Enforce compliance rules that must be followed 100% of the time.</p><p>A starter hook that prevents Claude from committing secrets:</p><pre>{<br>  &quot;hooks&quot;: {<br>    &quot;PreCommit&quot;: [{<br>      &quot;command&quot;: &quot;git diff --cached --name-only | grep -E &#39;\\.(env|pem|key)$&#39; &amp;&amp; echo &#39;BLOCKED: secret file&#39; &amp;&amp; exit 1 || exit 0&quot;<br>    }]<br>  }<br>}</pre><p>Add this to .claude/settings.json and it catches credential files before they ever reach your repo. Zero reliance on the model getting it right. Deterministic.</p><p>Recent additions include PostCompact hooks (fires after context compaction, useful for logging what got compressed) and ExitWorktree hooks.</p><p>Decision framework: hooks are deterministic guarantees. Use them for business rules that must work every time. Prompts are probabilistic guidance. Use them for preferences and soft rules. If the business would lose money or face legal risk from a single failure, use hooks.</p><h4>Model Context Protocol</h4><p>The open standard for connecting Claude to external services. Databases, application programming interfaces, GitHub, Slack, Telegram, Google Drive, and anything else you can build a server for.</p><p>Think of Model Context Protocol as USB-C for AI. Instead of building custom integrations for each data source, you build against one protocol. Model Context Protocol servers expose data and capabilities. Claude connects to them. The entire Channels feature is built on Model Context Protocol. The Telegram and Discord integrations are themselves Model Context Protocol servers. The plugin architecture runs on it.</p><p>Configuration lives in .mcp.json at the project level (version controlled, shared with the team) or ~/.claude.json for personal servers. Environment variable expansion (${GITHUB_TOKEN}) keeps credentials out of version control.</p><p>Before building a custom Model Context Protocol server, check if a community server already exists for your integration. Jira, GitHub, Slack, Notion, Linear, and dozens of other common tools already have community servers. Only build custom when community servers can’t handle your team-specific workflows.</p><p>Run /mcp periodically to check token costs per server. A forgotten Model Context Protocol connection can eat 15% of the context window every session. Disconnect servers you&#39;re not actively using.</p><h4>Plugins</h4><p>Plugins bundle skills, hooks, subagents, and Model Context Protocol servers into a single installable unit. One person builds a plugin that captures your team’s code review standards, deployment checklist, and architectural patterns. Everyone installs it. Consistent, process-compliant output across the organization because the standards live in the plugin, not in individual memory.</p><p>Plugin skills are namespaced (/my-plugin:review) so you can run five plugins without them stepping on each other. The March 20 release added the ability to declare plugin entries inline in settings.json.</p><p>Start by installing one official plugin that matches your role. Use it for a week. Then build your own that encodes the specific standards your team uses.</p><h4>Headless Mode and Continuous Integration/Deployment</h4><p>Claude Code runs in non-interactive mode with the -p flag. Without it, your CI job hangs waiting for interactive input.</p><p>Combine with --output-format json and --json-schema for machine-parseable structured output. Automated systems can post findings as inline pull request comments.</p><p>A basic GitHub Actions setup: trigger on pull request open, run claude -p &quot;review this diff for bugs and missing tests&quot; --output-format json, parse the output, post as review comments. Takes about 15 minutes to set up.</p><p>Always use an independent Claude instance for code review, not the same session that wrote the code. The session that generated code retains reasoning context that makes it less likely to question its own decisions. A fresh instance catches more.</p><h4>Claude Code Security</h4><p>Claude Code can review entire codebases to identify security vulnerabilities. Traditional scanners match code against known patterns and flag everything that looks suspicious, which produces 30–60% false positive rates and a lot of wasted time triaging noise. Claude reasons about code semantically instead, tracing data flows across the codebase and looking for logic flaws that cross file boundaries.</p><p>Anthropic reports a false positive rate below 5%. In testing with Opus 4.6, their security team found over 500 vulnerabilities in well-reviewed open-source projects, including bugs that had gone undetected for years. Claude then runs its own findings through a red-teaming process to filter out false positives.</p><h4>Voice Mode</h4><p>Claude Code supports voice input for hands-free coding. Toggle with /voice. You&#39;re reviewing code on one monitor and dictating refactoring notes without switching windows. It had some rough edges early on (WebSocket drops, activation quirks on fresh installs) but has been patched steadily.</p><h4>Automated Pull Request Workflows</h4><p>In headless mode (-p), Claude Code reads a pull request diff, evaluates code quality, flags bugs, checks for missing tests, and posts findings as inline comments. Combined with --output-format json, this slots directly into GitHub Actions or any continuous integration pipeline. Teams are also using Claude Code for automated preview generation and merge preparation, where Claude reviews changes, runs tests, generates a summary, and stages the merge if everything passes.</p><h3>Claude in Chrome</h3><p>The Chrome extension lets Claude read pages, click elements, fill forms, and navigate sites alongside you.</p><p>Features most people miss:</p><p>Record a workflow by showing Claude the steps once and it learns to repeat them. Any repetitive browser task you do more than twice a week should become a recorded workflow.</p><p>Claude Code integration lets you build in your terminal and test in the browser simultaneously. The extension reads console errors, network requests, and Document Object Model state, so when your frontend breaks, Claude already knows why before you ask.</p><p>You can control browser actions from Claude Desktop without switching windows. Admins on Team and Enterprise can manage the extension org-wide with allowlists and blocklists for site access.</p><p>Practical example: record a workflow for checking competitor pricing pages weekly. Claude navigates to each site, extracts the pricing data, and drops it into a comparison spreadsheet in your Cowork folder.</p><p>Be cautious about which sites you give access to. Web content is a primary vector for prompt injection. Limit access to trusted sites.</p><h3>Claude for Excel and PowerPoint</h3><p>Claude works as add-ins inside both apps. The March 11 update lets them share full context, so work in Excel (data analysis, formulas, pivot tables, conditional formatting) flows directly into PowerPoint (presentations, visualizations) without losing information. Skills work inside the add-ins too. Organizations on Amazon Bedrock, Google Cloud Vertex AI, or Microsoft Foundry can connect via a large language model gateway.</p><p>The workflow that saves the most time: drop raw data into Excel, tell Claude to analyze it, build the pivot tables, and highlight the key trends. Then open PowerPoint and tell Claude to build a presentation from those findings. The shared context means it already knows the data, the key takeaways, and the numbers. No re-explaining, no copy-pasting between apps. One creator reported going from raw quarterly data to a board-ready deck in 20 minutes.</p><p>Microsoft launched their own “Copilot Cowork” on March 9 powered by Claude’s models, as part of a new $99/user E7 licensing tier.</p><h3>Custom Visuals in Chat</h3><p>Shipped March 12 as a beta, available to all users including the free tier. Claude can now create interactive charts, diagrams, and visualizations inline in conversations. Built using HTML and SVG, they support hover and click interactions and evolve as the conversation continues.</p><p>These are different from Artifacts. Artifacts are persistent, shareable documents in a side panel. Inline visuals are ephemeral. They live in the conversation flow, change as you ask follow-ups, and can disappear as the chat evolves.</p><p>Use inline visuals when you’re exploring data or explaining a concept and want to see it while you talk. Use Artifacts when you need a finished deliverable to share or download. The practical sweet spot: “show me a flowchart of how this auth system works” in the middle of a debugging conversation. Claude draws it, you spot the broken step, you keep talking. No context switch to a separate tool.</p><h3>The Application Programming Interface</h3><p><strong>Adaptive thinking with configurable effort levels</strong> replaced the old budget_tokens approach. Set effort to &quot;medium&quot; on Sonnet 4.6 for most tasks and you&#39;ll cut costs without losing quality. The new &quot;max&quot; effort level on Opus 4.6 is there when you need peak capability. Thinking tokens are billed as output tokens at $25/M for Opus, so effort level is your primary cost control lever in automated pipelines.</p><p><strong>Fine-grained tool streaming</strong> is generally available, no beta header needed. Structured outputs are generally available. Data residency controls let you pin inference to the United States at 1.1x pricing. The 1 million token context window works automatically for requests over 200K tokens, no code changes required.</p><p><strong>Code execution is free</strong> when combined with web search or web fetch. Dynamic filtering on search results at no extra cost beyond standard tokens. Web search and web fetch are both generally available now with no beta header required.</p><p><strong>Application Programming Interface Skills</strong> are new and most developers haven’t found them yet. Anthropic ships pre-built skills for PowerPoint, Excel, Word, and PDF processing. You can also upload custom skills via the /v1/skills endpoints to package domain expertise and organizational workflows into reusable capabilities. Skills require code execution to be enabled. If you&#39;re building document processing pipelines on the application programming interface, this replaces a lot of custom tooling.</p><p><strong>Context compaction</strong> automatically summarizes older context as conversations approach limits. Fewer compaction events overall since the 1 million token window went generally available.</p><h3>The Numbers</h3><p>Anthropic closed a $30 billion Series G at a $380 billion valuation on February 12, 2026. Led by GIC and Coatue. The second largest venture funding deal of all time behind OpenAI’s $40 billion raise. Microsoft and Nvidia were among the contributors.</p><p>Run-rate revenue hit $14 billion, growing 10x annually for three straight years. Claude Code alone is at $2.5 billion in run-rate revenue, more than doubling since January. Business subscriptions quadrupled in the same period. Eight of the Fortune 10 are Claude customers. Over 500 customers spend more than $1 million annually, up from roughly a dozen two years ago. Customers spending over $100K annually grew 7x in the past year. Enterprise accounts for 80% of the business.</p><p>On the enterprise infrastructure side: health information portability and accountability act-ready Enterprise plans launched in January for healthcare organizations. The Enterprise Analytics application programming interface (February 13) gives programmatic access to usage and engagement data aggregated per organization per day. Any organization can now purchase Enterprise directly on the website without a sales conversation.</p><p>Anthropic also launched the Claude Partner Network with a $100 million investment in training, co-marketing, and technical architecture support. The first professional credential, the Claude Certified Architect (Foundations), dropped March 12 as a proctored architecture-level exam. It tests agentic design, Model Context Protocol integration, Claude Code configuration, and production reliability patterns. Accenture is training roughly 30,000 professionals on it. Anthropic Academy provides 15 free courses as the official prep path as of March 2, with two additional courses added since then. Additional certifications for sellers, developers, and advanced architects are planned for later this year.</p><p>Anthropic’s engineers use Claude for roughly 60% of their own work, up from 28% a year ago. They ship 60 to 100 internal releases per day. Cowork went from zero to launch in 10 days, built entirely with Claude Code.</p><h3>What This Means for Builders</h3><p>The infrastructure layer is commoditizing fast. Features that required custom frameworks six months ago are now native platform features. The moat was never the infrastructure. It’s always been taste, distribution, and what you build on top of the tools.</p><p>For builders shipping products on Claude, the extension system is where the capability lives. Skills, subagents, Agent Teams, hooks, Channels, Model Context Protocol, plugins. A well-configured Claude Code setup with custom skills and scoped agents is a different tool entirely from someone typing prompts into a chat window.</p><p>For knowledge workers, Cowork changes your daily workflow starting this week. Build your context folder. Set your global instructions. Install two plugins. Use AskUserQuestion on everything. Set up one scheduled task. The phone-to-desktop bridge with Dispatch means dead time becomes productive time.</p><p>For team leads, the plugin marketplace and enterprise features mean you can standardize how your entire organization uses Claude. Build plugins that encode your team’s institutional knowledge and distribute them. That’s how you go from “we use AI sometimes” to “AI is how we operate.”</p><h4><strong>Subscribe for More such Updates :)</strong></h4><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=65341c1cea30" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Claude Code Tips and Best Practices For Daily Use]]></title>
            <link>https://medium.com/@boredhead/claude-code-tips-and-best-practices-for-daily-use-4d1edcf3fabc?source=rss-f3b18b8c91bd------2</link>
            <guid isPermaLink="false">https://medium.com/p/4d1edcf3fabc</guid>
            <category><![CDATA[anthropic-claude]]></category>
            <category><![CDATA[claude-code-tips]]></category>
            <category><![CDATA[claude]]></category>
            <category><![CDATA[claude-code]]></category>
            <dc:creator><![CDATA[boredhead]]></dc:creator>
            <pubDate>Fri, 20 Mar 2026 19:03:02 GMT</pubDate>
            <atom:updated>2026-03-20T19:03:02.064Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*AqZ0OTii4AX-Z0HVcyEYEw.png" /><figcaption>Claude Code best Practices</figcaption></figure><p><strong>1. Set up the cc alias</strong></p><p>Add this to your ~/.zshrc or ~/.bashrc:</p><pre>alias cc=&#39;claude --dangerously-skip-permissions&#39;</pre><p>Run source ~/.zshrc to load it. Now you type cc instead of claude and skip every permission prompt. The flag name is intentionally scary. Only use it after you fully understand what Claude Code can and will do to your codebase.</p><p><strong>2. Prefix ! to run bash commands inline</strong></p><p>Type !git status or !npm test and the command runs immediately. The output lands in context, so Claude can see the result and act on it. Faster than asking Claude to run a command.</p><p><strong>3. Hit Esc to stop Claude. Hit Esc+Esc to rewind anything.</strong></p><p>Esc stops Claude mid-action without losing context. You can redirect immediately.</p><p>Esc+Esc (or /rewind) opens a scrollable menu of every checkpoint Claude has created. You can restore the code, the conversation, or both. &quot;Undo that&quot; works too. Four restore options: code and conversation, conversation only, code only, or summarize from a checkpoint forward.</p><p>This means you can try the approach you’re only 40% sure about. If it works, great. If not, rewind. Zero damage done. One caveat: checkpoints only track file edits. Changes from bash commands (migrations, database operations) aren’t captured.</p><p>To pick up where you left off, claude --continue resumes your most recent conversation and claude --resume opens a session picker.</p><p><strong>4. Give Claude a way to check its own work</strong></p><p>Give Claude a feedback loop so it catches its own mistakes. Include test commands, linter checks, or expected outputs in your prompt.</p><pre>Refactor the auth middleware to use JWT instead of session tokens.<br>Run the existing test suite after making changes.<br>Fix any failures before calling it done.</pre><p>Claude runs the tests, sees failures, and fixes them without you stepping in. Boris Cherny says this alone gives a 2–3x quality improvement. For UI changes, set up the Playwright Model Context Protocol server so Claude can open a browser, interact with the page, and verify the UI works as expected. That feedback loop catches issues that unit tests miss.</p><p><strong>5. Install a code intelligence plugin for your language</strong></p><p>Language Server Protocol plugins give Claude automatic diagnostics after every file edit. Type errors, unused imports, missing return types. Claude sees and fixes issues before you even notice them. This is the single highest-impact plugin you can install.</p><p>Pick yours and run the install command:</p><pre>/plugin install typescript-lsp@claude-plugins-official<br>/plugin install pyright-lsp@claude-plugins-official<br>/plugin install rust-analyzer-lsp@claude-plugins-official<br>/plugin install gopls-lsp@claude-plugins-official</pre><p>Plugins for C#, Java, Kotlin, Swift, PHP, Lua, and C/C++ are also available. Run /plugin and go to the Discover tab to browse the full list. You&#39;ll need the corresponding language server binary installed on your system (the plugin will tell you if it&#39;s missing).</p><p><strong>6. Use the gh CLI and teach Claude any CLI tool</strong></p><p>The gh CLI handles pull requests, issues, and comments without a separate Model Context Protocol server. Command-line interface tools are more context-efficient than Model Context Protocol servers because they don’t load tool schemas into your context window. Same applies to jq, curl, and other standard CLI tools.</p><p>For tools Claude doesn’t know yet: “Use sentry-cli --help to learn about it, then use it to find the most recent error in production.&quot; Claude reads the help output, figures out the syntax, and runs the commands. Even niche internal CLIs work.</p><p><strong>7. Add “ultrathink” for complex reasoning</strong></p><p>It’s a keyword that sets effort to high and triggers adaptive reasoning on Opus 4.6. Claude dynamically allocates thinking based on the problem. Use it for architecture decisions, tricky debugging, multi-step reasoning, or anything where you want Claude to think before acting.</p><p>You can also set effort permanently with /effort. For less complex tasks, lower effort levels keep things fast and cheap. Match the effort to the problem. There&#39;s no point burning thinking tokens on a variable rename.</p><p><strong>8. Use skills for on-demand knowledge</strong></p><p>Skills are markdown files that extend Claude’s knowledge on demand. Unlike CLAUDE.md which loads every session, skills load only when relevant to the current task. This keeps your context lean.</p><p>Create skills in .claude/skills/ or install plugins that bundle pre-built skills (run /plugin to browse what&#39;s available). Use skills for specialized domain knowledge (Application Programming Interface conventions, deployment procedures, coding patterns) that Claude needs sometimes but not always.</p><p><strong>9. Control Claude Code from your phone</strong></p><p>Run claude remote-control to start a session, then connect to it from claude.ai/code or the Claude app on iOS/Android. The session runs locally on your machine. The phone or browser is just a window into it. You can send messages, approve tool calls, and monitor progress from anywhere.</p><p>If you’re using the cc alias from tip #1, Claude already has full permissions and won&#39;t need approval for each action. Kick off a task, walk away, and check in from your phone only when Claude finishes or hits something unexpected.</p><p><strong>10. Extend your context window to 1M tokens</strong></p><p>Both Sonnet 4.6 and Opus 4.6 support 1M token context windows. On Max, Team, and Enterprise plans, Opus is automatically upgraded to 1M context. You can also switch models mid-session with /model opus[1m] or /model sonnet[1m].</p><p>If you’re concerned about quality at larger context sizes, start at 500k and work up gradually. Use CLAUDE_CODE_AUTO_COMPACT_WINDOW to control when compaction triggers, and CLAUDE_AUTOCOMPACT_PCT_OVERRIDE to set the percentage threshold.</p><p><strong>11. Use Plan Mode when you’re not sure how to approach something</strong></p><p>Use Plan Mode for multi-file changes, unfamiliar code, and architectural decisions. The overhead is real (a few extra minutes upfront), but it prevents Claude from spending 20 minutes confidently solving the wrong problem.</p><p>Skip it for small, clear-scope tasks. If you can describe the diff in one sentence, just do it directly. You can switch into Plan Mode anytime with Shift+Tab to cycle between Normal, Auto-Accept, and Plan permission modes without leaving the conversation.</p><p><strong>12. Run /clear between unrelated tasks</strong></p><p>A clean session with a sharp prompt beats a messy three-hour session. Different task? /clear first.</p><p>Sessions degrade because accumulated context from earlier work drowns out your current instructions. The five seconds it takes to /clear and write a focused starting prompt saves you from 30 minutes of diminishing returns.</p><p><strong>13. Stop interpreting bugs for Claude. Paste the raw data.</strong></p><p>Describing a bug in words is slow. You watch Claude guess, correct it, and repeat.</p><p>Paste the error log, CI output, or Slack thread directly and say “fix.” Claude reads logs from distributed systems and traces where things break. Your interpretation adds abstraction that often loses the detail Claude needs to pinpoint the root cause.</p><p>This works for CI too. “Go fix the failing CI tests” with a paste of the CI output is one of the most reliable patterns. You can also paste a pull request URL or number and ask Claude to check the failing checks and fix them. With the gh CLI from tip #6 installed, Claude handles the rest.</p><p>You can also pipe output directly from the terminal:</p><pre>cat error.log | claude &quot;explain this error and suggest a fix&quot;<br>npm test 2&gt;&amp;1 | claude &quot;fix the failing tests&quot;</pre><p><strong>14. Use /btw for quick side questions</strong></p><p>/btw pops up an overlay for a quick question without entering your conversation history. Use it for clarifications about the current session: &quot;Why did you choose this approach?&quot; or &quot;What&#39;s the tradeoff with the other option?&quot; The answer shows in a dismissible overlay, your main context stays lean, and Claude keeps working.</p><p><strong>15. Use — worktree for isolated parallel branches</strong></p><p>claude --worktree feature-auth creates an isolated working copy with a new branch. Claude handles the git worktree setup and cleanup.</p><p>The Claude Code team calls this one of the biggest productivity unlocks. Spin up 3–5 worktrees, each running its own Claude session in parallel. Each worktree gets its own session, its own branch, and its own file system state. The ceiling on local worktrees is your machine: multiple dev servers, builds, and Claude sessions all competing for CPU.</p><p><strong>16. Stash your prompt with Ctrl+S</strong></p><p>You’re halfway through writing a long prompt and realize you need a quick answer first. Ctrl+S stashes your draft. Type your quick question, submit it, and your stashed prompt restores automatically.</p><p><strong>17. Background long-running tasks with Ctrl+B</strong></p><p>When Claude kicks off a long bash command (a test suite, a build, a migration), press Ctrl+B to send it to the background. Claude continues working while the process runs. The result appears when the process finishes.</p><p><strong>18. Add a live status line</strong></p><p>The status line is a shell script that runs after every Claude turn. It displays live information at the bottom of your terminal: current directory, git branch, context usage color-coded by how full the window is.</p><p>The fastest way to set one up is /statusline inside Claude Code. It&#39;ll ask what you want to display and generate the script for you.</p><p><strong>19. Use subagents to keep your main context clean</strong></p><p>“Use subagents to figure out how the payment flow handles failed transactions.” This spawns a separate Claude instance with its own context window. It reads all the files, reasons about the codebase, and reports back a concise summary.</p><p>Your main session stays clean with plenty of room to build something. A deep investigation can consume half your context window before you write any code. Built-in types include Explore (Haiku, fast file search) and Plan (read-only analysis).</p><p><strong>20. Agent teams for multi-session coordination</strong></p><p>Experimental but powerful. Enable it first by adding CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS to your settings or environment. Then tell Claude to create a team: &quot;Create an agent team with 3 teammates to refactor these modules in parallel.&quot; A team lead distributes work to teammates, each with their own context window and a shared task list. Teammates can message each other directly to coordinate.</p><p>Start with 3–5 teammates and 5–6 tasks per teammate. Avoid assigning tasks that modify the same files. Two teammates editing the same file leads to overwrites. Start with research and review tasks (pull request reviews, bug investigations) before attempting parallel implementation.</p><p><strong>21. Guide compaction with instructions</strong></p><p>When context compacts (automatically or via /compact), tell Claude what to preserve: &quot;/compact focus on the Application Programming Interface changes and the list of modified files.&quot; You can also add standing instructions to your CLAUDE.md: &quot;When compacting, preserve the full list of modified files and current test status.&quot;</p><p><strong>22. Use /loop for recurring checks</strong></p><p>/loop 5m check if the deploy succeeded and report back schedules a recurring prompt that fires in the background while your session stays open. The interval is optional (defaults to 10 minutes) and supports s, m, h, and d units. You can also loop over other commands: /loop 20m /review-pr 1234. Tasks are session-scoped and expire after 3 days. Use /loop for monitoring deploys, watching CI pipelines, or polling an external service while you focus on something else.</p><p><strong>23. Use voice dictation for richer prompts</strong></p><p>Run /voice to enable push-to-talk, then hold Space to dictate. Your speech transcribes live into the prompt, and you can mix voice and typing in the same message. Spoken prompts naturally include more context than typed ones because you explain the background, mention constraints, and describe what you want without cutting corners to save keystrokes.</p><p>Requires a Claude.ai account (not Application Programming Interface key). You can rebind the push-to-talk key to a modifier combo like meta+k in ~/.claude/keybindings.json to skip the hold-detection warmup.</p><p><strong>24. After 2 corrections on the same thing, start fresh</strong></p><p>When you and Claude are going down a rabbit hole of corrections and the issue still isn’t fixed, the context is full of failed approaches that are actively hurting the next attempt. /clear and write a better starting prompt that incorporates what you learned. A clean session with a sharper prompt almost always outperforms a long session weighed down by accumulated dead ends.</p><p><strong>25. Tell Claude exactly which files to look at</strong></p><p>Use @ to reference files directly: @src/auth/middleware.ts has the session handling. The @ prefix resolves to the file path automatically.</p><p>Claude can grep and search your codebase on its own, but it still has to narrow down candidates and identify the right file. Every search step costs tokens and context. Pointing Claude at the right files from the start skips that entire process.</p><p><strong>26. Explore unfamiliar code with vague prompts</strong></p><p>“What would you improve in this file?” is a great exploration prompt. When you want fresh eyes on existing code, a vague question gives Claude room to surface things you wouldn’t have thought to ask about. I use this when onboarding onto an unfamiliar repo.</p><p><strong>27. Edit plans with Ctrl+G</strong></p><p>When Claude presents a plan, Ctrl+G opens it in your text editor for direct editing. Add constraints, remove steps, redirect the approach before Claude writes a single line of code. Useful when the plan is mostly right but you want to tweak a few steps without re-explaining the whole thing.</p><p><strong>28. Run /init, then cut the result in half</strong></p><p>CLAUDE.md is a markdown file at the root of your project that gives Claude persistent instructions: build commands, coding standards, architectural decisions, repo conventions. Claude reads it at the start of every session. /init generates a starter version based on your project structure.</p><p>The output tends to be bloated. If you can’t explain why a line is there, delete it. Trim the noise and add what’s missing.</p><p><strong>29. The litmus test for every CLAUDE.md line</strong></p><p>For every line in your CLAUDE.md, ask: would Claude make a mistake without this? If Claude already does something correctly on its own, the instruction is noise. Every unnecessary line dilutes the ones that matter. There’s roughly a 150–200 instruction budget before compliance drops off, and the system prompt already uses about 50 of those.</p><p><strong>30. After Claude makes a mistake, say “Update your CLAUDE.md so this doesn’t happen again”</strong></p><p>Claude writes its own rule. Next session, it follows it automatically.</p><p>Over time your CLAUDE.md becomes a living document shaped by real mistakes. To keep it from growing indefinitely, use @imports (tip #32) to reference a separate file like @docs/solutions.md for patterns and fixes. Your CLAUDE.md stays lean, and Claude reads the details on demand.</p><p><strong>31. Use .claude/rules/ for rules that only apply sometimes</strong></p><p>Place markdown files in .claude/rules/ to organize instructions by topic. By default, every rule file loads at the start of each session. To make a rule load only when Claude works on specific files, add paths frontmatter:</p><pre>---<br>paths:<br>  - &quot;**/*.ts&quot;<br>---<br># TypeScript conventions<br>Prefer interfaces over types.</pre><p>TypeScript rules load when Claude reads .ts files, Go rules when it reads .go files. Claude never wades through conventions for languages it isn&#39;t touching.</p><p><strong>32. Use @imports to keep CLAUDE.md lean</strong></p><p>Reference docs with @docs/git-instructions.md. You can also reference @README.md, @package.json, or even @~/.claude/my-project-instructions.md.</p><p>Claude reads the file when it needs it. Think of @imports as &quot;here&#39;s more context if you need it&quot; without bloating the file Claude reads every session.</p><p><strong>33. Allowlist safe commands with /permissions</strong></p><p>Stop clicking “approve” on npm run lint for the hundredth time. /permissions lets you allowlist trusted commands so you stay in flow. You&#39;ll still get prompted for anything not on the list.</p><p><strong>34. Use /sandbox when you want Claude to work freely</strong></p><p>Run /sandbox to enable operating system-level isolation. Writes are restricted to your project directory, and network requests are limited to domains you approve. It uses Seatbelt on macOS and bubblewrap on Linux, so restrictions apply to every subprocess Claude spawns. In auto-allow mode, sandboxed commands run without permission prompts.</p><p>For unsupervised work (overnight migrations, experimental refactors), run Claude in a Docker container. Containers give you full isolation, easy rollback, and the confidence to let Claude run for hours.</p><p><strong>35. Create custom subagents for recurring tasks</strong></p><p>Custom subagents are pre-configured agents saved in .claude/agents/. For example, a security-reviewer agent with Opus and read-only tools, or a quick-search agent with Haiku for speed.</p><p>Use /agents to browse and create them. You can set isolation: worktree for agents that need their own file system.</p><p><strong>36. Pick the right Model Context Protocol servers for your stack</strong></p><p>The Model Context Protocol servers worth starting with: Playwright for browser testing and UI verification, PostgreSQL/MySQL for direct schema queries, Slack for reading bug reports and thread context, and Figma for design-to-code workflows.</p><p>Claude Code supports dynamic tool loading, so servers only load their definitions when Claude needs them.</p><p><strong>37. Set your output style</strong></p><p>Run /config and select your preferred style. The built-in options are Explanatory (detailed, step-by-step), Concise (brief, action-focused), and Technical (precise, jargon-friendly).</p><p>You can also create custom output styles as files in ~/.claude/output-styles/.</p><p><strong>38. Use CLAUDE.md for suggestions, hooks for requirements</strong></p><p>CLAUDE.md is advisory. Claude follows it about 80% of the time. Hooks are deterministic, 100%. If something must happen every time without exception (formatting, linting, security checks), make it a hook. If it’s guidance Claude should consider, CLAUDE.md is fine.</p><p><strong>39. Auto-format with a PostToolUse hook</strong></p><p>Every time Claude edits a file, your formatter should run automatically. Add a PostToolUse hook in .claude/settings.json that runs Prettier on any file after Claude edits or writes it:</p><pre>{<br>  &quot;hooks&quot;: {<br>    &quot;PostToolUse&quot;: [<br>      {<br>        &quot;matcher&quot;: &quot;Edit|Write&quot;,<br>        &quot;hooks&quot;: [<br>          {<br>            &quot;type&quot;: &quot;command&quot;,<br>            &quot;command&quot;: &quot;npx prettier --write \&quot;$CLAUDE_FILE_PATH\&quot; 2&gt;/dev/null || true&quot;<br>          }<br>        ]<br>      }<br>    ]<br>  }<br>}</pre><p>The || true prevents hook failures from blocking Claude. You can chain other tools too. Add npx eslint --fix as a second hook entry.</p><p>If you have an editor open to the same files, consider turning off format-on-save while Claude is working. Some developers have reported that editor saves can invalidate the prompt cache, forcing Claude to re-read files.</p><p><strong>40. Block destructive commands with PreToolUse hooks</strong></p><p>Block rm -rf, drop table, and truncate patterns with a PreToolUse hook on Bash. The hook fires before Claude executes the tool, so destructive commands get caught before they cause damage.</p><pre>{<br>  &quot;hooks&quot;: {<br>    &quot;PreToolUse&quot;: [<br>      {<br>        &quot;matcher&quot;: &quot;Bash&quot;,<br>        &quot;type&quot;: &quot;command&quot;,<br>        &quot;command&quot;: &quot;if echo \&quot;$TOOL_INPUT\&quot; | grep -qE &#39;rm -rf|drop table|truncate&#39;; then echo &#39;BLOCKED: destructive command&#39; &gt;&amp;2; exit 2; fi&quot;<br>      }<br>    ]<br>  }<br>}</pre><p>Add this to .claude/settings.json in your project. You can set it up interactively with /hooks, or just tell Claude: &quot;Add a PreToolUse hook that blocks rm -rf, drop table, and truncate commands.&quot;</p><p><strong>41. Preserve important context across compaction with hooks</strong></p><p>When context compacts during long sessions, Claude can lose track of what you’re working on. A Notification hook with a compact matcher automatically re-injects your key context every time compaction fires.</p><p>Tell Claude: “Set up a Notification hook that after compaction reminds you of the current task, modified files, and any constraints.” Claude will create the hook in your settings. Good candidates for re-injection: the current task description, the list of files you’ve modified, and any hard constraints (“don’t modify migration files”).</p><p>This is most valuable during multi-hour sessions where you’re deep in a feature and can’t afford Claude losing the thread.</p><p><strong>42. Always manually review auth, payments, and data mutations</strong></p><p>Claude is good at code. These decisions need a human. Auth flows, payment logic, data mutations, destructive database operations. Review these regardless of how good the rest looks. A wrong auth scope, a misconfigured payment webhook, or a migration that drops a column silently can cost you users, money, or trust.</p><p><strong>43. Use /branch to try a different approach without losing your current one</strong></p><p>/branch (or /fork) creates a copy of your conversation at the current point. Try the risky refactor in the branch. If it works, keep it. If it doesn&#39;t, your original conversation is untouched. This is different from rewind (#3) because both paths stay alive.</p><p><strong>44. Let Claude interview you when you can’t fully spec a feature</strong></p><p>You know what you want to build, but you don’t have all the details Claude needs to build it well.</p><pre>I want to build [brief description]. Interview me in detail<br>using the AskUserQuestion tool. Ask about technical implementation,<br>edge cases, concerns, and tradeoffs. Don&#39;t ask obvious questions.<br>Keep interviewing until we&#39;ve covered everything,<br>then write a complete spec to SPEC.md.</pre><p>Once the spec is done, start a fresh session to execute with clean context and a complete spec.</p><p><strong>45. Have one Claude write, another Claude review</strong></p><p>First Claude implements the feature, second Claude reviews from fresh context like a staff engineer. The reviewer has no knowledge of the implementation shortcuts and will challenge every one of them.</p><p>Same idea works for test-driven development. Session A writes tests, Session B writes the code to pass them.</p><p><strong>46. Review pull requests conversationally</strong></p><p>Open the pull request in a session and have a conversation about it. “Walk me through the riskiest change in this pull request.” “What would break if this runs concurrently?” “Is the error handling consistent with the rest of the codebase?”</p><p>Conversational reviews catch more issues because you can drill into the areas that matter. One-shot reviews tend to flag style nits and often miss the architectural problems.</p><p><strong>47. Name and color-code your sessions</strong></p><p>/rename auth-refactor puts a label on the prompt bar. /color red or /color blue sets the prompt bar color. Available colors: red, blue, green, yellow, purple, orange, pink, cyan. When you&#39;re running 2-3 parallel sessions, naming and coloring them takes five seconds and saves you from typing into the wrong terminal.</p><p><strong>48. Play a sound when Claude finishes</strong></p><p>Add a Stop hook that plays a system sound when Claude completes a response. Kick off a task, switch to something else, and hear a ping when it’s done.</p><pre>{<br>  &quot;hooks&quot;: {<br>    &quot;Stop&quot;: [<br>      {<br>        &quot;matcher&quot;: &quot;*&quot;,<br>        &quot;hooks&quot;: [<br>          {<br>            &quot;type&quot;: &quot;command&quot;,<br>            &quot;command&quot;: &quot;/usr/bin/afplay /System/Library/Sounds/Glass.aiff&quot;<br>          }<br>        ]<br>      }<br>    ]<br>  }<br>}</pre><p><strong>49. Fan-out with claude -p for batch operations</strong></p><p>Loop through a list of files with non-interactive mode. --allowedTools scopes what Claude can do per file. Run them in parallel with &amp; for maximum throughput.</p><pre>for file in $(cat files-to-migrate.txt); do<br>  claude -p &quot;Migrate $file from class components to hooks&quot; \<br>    --allowedTools &quot;Edit,Bash(git commit *)&quot; &amp;<br>done<br>wait</pre><p>Great for converting file formats, updating imports across a codebase, and running repetitive migrations where each file is independent of the others.</p><p><strong>50. Customise the spinner verbs</strong></p><p>While Claude thinks, the terminal shows a spinner with verbs like “Flibbertigibbeting…” and “Flummoxing…”. You can replace them with whatever you want. Tell Claude:</p><pre>Replace my spinner verbs in user settings with these: Hallucinating responsibly, Pretending to think, Confidently guessing, Blaming the context window</pre><p>You don’t have to provide a list. Just tell Claude what vibe you’re going for: “Replace my spinner verbs with Harry Potter spells.” Claude generates the list.</p><h4>Subscribe to get more such post updates.</h4><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=4d1edcf3fabc" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Rating Claude Cowork Plugins]]></title>
            <link>https://medium.com/@boredhead/rating-claude-cowork-plugins-eba04fb1327f?source=rss-f3b18b8c91bd------2</link>
            <guid isPermaLink="false">https://medium.com/p/eba04fb1327f</guid>
            <category><![CDATA[anthropic-claude]]></category>
            <category><![CDATA[claude]]></category>
            <category><![CDATA[claude-cowork]]></category>
            <dc:creator><![CDATA[boredhead]]></dc:creator>
            <pubDate>Fri, 20 Mar 2026 18:32:27 GMT</pubDate>
            <atom:updated>2026-03-20T18:33:25.276Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*RchbYcaF5XsthiVj.png" /><figcaption>Claude Cowork Plugins.</figcaption></figure><p>Anthropic shipped 21 plugins for Claude Cowork. The original 11 launched on January 30. Ten more dropped on February 24.</p><p>I’ve been using Cowork since launch week. Installed every plugin. Tested every slash command. Ran real work through each one: client proposals, financial models, content calendars, contract reviews, and dataset explorations. Not demos, not test prompts. Actual deliverables.</p><p>Here’s what I found.</p><p><strong>What plugins actually are</strong></p><p>Most people think plugins are just better prompts. They’re not.</p><p>A plugin is a folder containing four things: skills (domain expertise Claude draws on automatically), slash commands (structured workflows you trigger explicitly), connectors (live integrations with external tools via Model Context Protocol), and sub-agents (parallel workers Claude can spin up for complex tasks).</p><p>When you install the Sales plugin, you’re not loading a “write me a sales email” prompt. You’re loading an entire sales methodology into Claude’s working memory. It knows what a good call prep looks like. It knows how to structure a competitive battlecard. It knows to ask about deal stage before drafting outreach.</p><p>The difference between a generic Cowork prompt and a plugin-powered prompt is the difference between asking a smart generalist and asking someone who’s done your specific job for five years.</p><p>Not all plugins deliver on this equally.</p><p><strong>S-Tier: Install these immediately</strong></p><p>These changed how I work within the first session.</p><p><strong>1. Data Analysis</strong></p><p>This is the single most impressive plugin in the library.</p><p>Drop a CSV into your Cowork folder. Type /data:explore. Claude reads the full dataset, summarizes every column, flags anomalies, detects data quality issues, and suggests three analyses worth running before you&#39;ve told it what you&#39;re looking for.</p><p>Type /data:write-query and describe what you want in plain English. It writes the SQL, validates the query, and explains what it&#39;s doing. Connect it to Snowflake, Databricks, or BigQuery and it runs queries against live data.</p><p>I ran a client’s quarterly revenue data through it: 45,000 rows across three product lines. Within eight minutes, Claude had identified a pricing anomaly in their mid-tier plan that was costing them roughly $14,000 per month in undercharged renewals. The client’s own data team had missed it for two quarters.</p><p>Connectors: Snowflake, Databricks, BigQuery, Hex, Amplitude, Jira.</p><p><strong>2. Productivity</strong></p><p>Install this first, regardless of role.</p><p>It manages tasks, calendars, daily workflows, and personal context. Type /productivity:start and Claude reviews your day, organizes priorities, and sets up your task list. Connects to Slack, Notion, Asana, Linear, Jira, Monday, ClickUp, and Microsoft 365.</p><p>What makes it S-tier isn’t any single feature. It compounds. After a week of use, the Productivity plugin paired with good context files and global instructions makes Claude feel like a chief of staff who knows your schedule, your priorities, and your working style.</p><p>I start every day with it now. Before email. Before Notion.</p><p><strong>3. Sales</strong></p><p>If you do any prospecting, account management, or outreach, this plugin is absurdly good.</p><p>/sales:call-prep pulls context from your Customer Relationship Management platform (via HubSpot, Close, or Clay connectors), researches the prospect&#39;s company, identifies recent news and triggers, and produces a structured briefing doc. Output includes talking points, potential objections, competitive positioning, and suggested next steps.</p><p>The battlecard command (/sales:battlecard) is particularly strong. Feed it your product info and a competitor, and it builds a side-by-side comparison with specific rebuttal language. Not generic talking points. Actual responses mapped to specific competitor claims.</p><p>One sales manager I shared this with told me it replaced 90 minutes of pre-call prep. He now does it in under 10.</p><p>Connectors: Slack, HubSpot, Close, Clay, ZoomInfo, Notion, Jira, Fireflies, Microsoft 365.</p><p><strong>A-Tier: Genuinely useful, worth installing for your role</strong></p><p>These deliver strong results but are more role-specific. Install the ones that match your job function.</p><p><strong>4. Legal</strong></p><p>This is the plugin that crashed $285 billion in market value.</p><p>It automates contract review, non-disclosure agreement triage, compliance workflows, legal briefings, and templated responses. It doesn’t replace lawyers. It does the 60% of legal work that used to get delegated to junior associates and paralegals.</p><p>Thomson Reuters shares fell 18% when this launched, their worst day on record. RELX, which owns LexisNexis, dropped 14%, its steepest single-day decline since 1988. Wolters Kluwer fell 13%. LegalZoom plunged 20%. Morningstar’s analysts noted Thomson is most at risk, with 45% of earnings before interest and taxes coming from legal.</p><p>Within three weeks, LexisNexis announced it was integrating the legal plugin into its Protegé platform. One law firm user described the shift as “going from a horse and buggy to a Maserati.”</p><p>A-tier and not S-tier because it requires significant customization to match your organization’s specific playbook and risk tolerances. Out of the box, it’s powerful. Customized, it’s a different category of tool.</p><p>Connectors: Slack, Box, Egnyte, Jira, Microsoft 365. Harvey connector added February 24.</p><p><strong>5. Product Management</strong></p><p>This one surprised me.</p><p>/product-management:write-spec takes a vague product idea and turns it into a structured specification with user stories, acceptance criteria, and technical requirements. It asks clarifying questions first, which means output is grounded in your actual constraints, not generic templates.</p><p>The roadmap command synthesizes your backlog, stakeholder input, and competitive context into a prioritized roadmap. The competitive analysis feature pulls from connected tools and produces a structured brief that would take a product manager two to three hours to assemble manually.</p><p>Connectors: Slack, Linear, Asana, Monday, ClickUp, Jira, Notion, Figma, Amplitude, Pendo, Intercom, Fireflies.</p><p><strong>6. Marketing</strong></p><p>Content drafting, campaign planning, brand voice enforcement, competitor briefings, and performance reporting. Full content lifecycle.</p><p>/marketing:draft-content is the standout command. Point it at your brand-voice.md file, specify audience and goal, and it produces content that sounds like your brand. Not generic AI voice. Your voice.</p><p>The campaign planning workflow helps you build multi-channel plans with specific messaging, timing, and metrics per channel. The competitive briefing command pulls insights from connected tools and structures them for quick decision-making.</p><p>Connectors: Slack, Canva, Figma, HubSpot, Amplitude, Notion, Ahrefs, SimilarWeb, Klaviyo.</p><p><strong>7. Finance</strong></p><p>PwC partnered with Anthropic specifically around this plugin category.</p><p>It handles journal entries, account reconciliation, financial statement generation, variance analysis, close management, and audit support. The Financial Analysis plugin (added February 24) covers market research, competitive analysis, financial modeling, and PowerPoint template creation and quality checking.</p><p>Where it shines: the cross-app workflow between Excel and PowerPoint. Claude can analyze data in Excel and pass that context directly into a PowerPoint presentation, formatted and branded. First time an AI tool has worked across Microsoft Office apps in a way that feels seamless.</p><p>Connectors: Snowflake, Databricks, BigQuery, Slack, Microsoft 365. New connectors: FactSet, MSCI.</p><p><strong>B-Tier: Solid foundation, needs your customization</strong></p><p>These work. They produce useful output. But they feel like starting templates more than finished products. Budget 30 to 60 minutes to customize them for your specific workflows.</p><p><strong>8. Customer Support</strong></p><p>Ticket triage, response drafting, escalation packaging, customer context research, and knowledge base article creation. The loop from resolved ticket to published knowledge base article is smart: it identifies patterns in resolved issues and suggests documentation.</p><p>Why B-tier: default response templates are too generic. Feed it your company’s tone, your escalation criteria, and your specific service level agreement structure. Once you do, it’s strong. Without that, outputs feel boilerplate.</p><p>Connectors: Slack, Intercom, HubSpot, Guru, Jira, Notion, Microsoft 365.</p><p><strong>9. HR (New, February 24)</strong></p><p>Offer letter drafting, onboarding plans, performance reviews, and compensation analyses.</p><p>The performance review workflow is notably good. It structures feedback around specific, observable behaviors rather than vague personality assessments. The compensation analysis feature needs your company’s bands and market data to be useful, but once configured, it can flag equity gaps across teams.</p><p>B-tier because it requires substantial company-specific input to produce outputs worth using. The framework underneath is solid.</p><p><strong>10. Engineering (New, February 24)</strong></p><p>Standup summaries, incident response coordination, deploy checklists, and postmortem drafting. If your engineering team uses Claude Code, this plugin extends that capability to the non-coding work that eats up engineering managers’ days.</p><p>The postmortem template is thorough: timeline, root cause, contributing factors, customer impact, and action items with owners and deadlines. Better than most internal templates I’ve seen.</p><p>Needs customization to match your team’s incident severity levels and communication protocols.</p><p><strong>11. Operations (New, February 24)</strong></p><p>Process documentation, vendor evaluations, change request tracking, and runbook creation.</p><p>The vendor evaluation workflow structures comparisons across defined criteria and produces a decision matrix. The runbook creation command takes verbal descriptions of processes and turns them into step-by-step documentation that’s actually followable.</p><p>B-tier because operations workflows vary enormously between companies. The plugin gives you scaffolding. You supply the specifics.</p><p><strong>12. Design (New, February 24)</strong></p><p>Critique frameworks, user experience copy drafting, accessibility audits, and user research plan structuring. Aimed at design teams, not graphic design. It won’t generate images.</p><p>The accessibility audit workflow is rigorous. Feed it your design specs or screenshots and it flags Web Content Accessibility Guidelines compliance issues with specific remediation suggestions. The user experience copy drafting depends heavily on how well your brand-voice.md file is written.</p><p>Solid starting point. Customize the critique frameworks to match your team’s design principles.</p><p><strong>C-Tier: Promising concept, limited out-of-box value</strong></p><p>These have clear potential but aren’t delivering consistently yet. Install if your role demands it, but adjust your expectations.</p><p><strong>13. Enterprise Search</strong></p><p>One query across email, chat, docs, and wikis. Find anything across all your tools in a single search.</p><p>In practice, search quality depends entirely on how many connectors you’ve configured and how well-structured your company’s documentation is. If your Notion is a mess, Enterprise Search reflects that mess back at you, just faster.</p><p>Connectors: Slack, Notion, Guru, Jira, Asana, Microsoft 365. Useful when fully connected. Most people won’t have all those configured on day one.</p><p><strong>14. Bio Research</strong></p><p>Connects to PubMed, BioRender, bioRxiv, ClinicalTrials.gov, ChEMBL, Synapse, Wiley, Owkin, Open Targets, and Benchling. That connector list is remarkable.</p><p>For life sciences researchers doing literature reviews, genomics analysis, or target prioritization, this has real potential. Anthropic’s partnerships with the Allen Institute and the Howard Hughes Medical Institute signal they’re serious about this space.</p><p>C-tier because the user base is narrow and the workflows are highly specialized. If you’re in biotech research and development, try it. Otherwise, skip.</p><p><strong>15. Cowork Plugin Management</strong></p><p>This is the meta-plugin: it helps you create and customize other plugins. Essential for teams building custom ones, irrelevant for individuals who just want to install and use what exists.</p><p>If you’re an admin setting up Cowork for your team, this moves to A-tier. Everyone else will probably never need it.</p><p><strong>The February 24 Financial Services Wave: Early Assessment</strong></p><p>Anthropic dropped four finance-specific plugins on February 24. These were less than 48 hours old at time of writing. Initial assessments:</p><p><strong>16. Financial Analysis: B-Tier</strong> Market research, competitive analysis, financial modeling, and PowerPoint creation and quality checking. Generalist finance, useful across roles. The cross-app Excel-to-PowerPoint workflow is the standout. Needs company-specific templates and data sources to reach its potential.</p><p><strong>17. Investment Banking: B-Tier</strong> Transaction document review, comparable company analyses, and pitch material preparation. Strong framework for deal workflows. Needs your firm’s formatting standards, precedent transactions database, and sector coverage to be genuinely useful.</p><p><strong>18. Equity Research: B-Tier</strong> Earnings transcript parsing, financial model updates with new guidance, and research note drafting. The transcript parsing is immediately useful: extracts key metrics, management commentary, and guidance changes. Research note drafting needs heavy customization to match your publishing standards.</p><p><strong>19. Private Equity: B-Tier</strong> Deal sourcing support, large document set review, standardized financial data extraction, scenario modeling, and opportunity scoring against investment criteria. Document review is the most immediately valuable. Scoring frameworks need your fund’s specific criteria and weighting.</p><p><strong>20. Wealth Management: C-Tier</strong> Portfolio analysis, drift and tax exposure identification, and rebalancing recommendations at scale. Conceptually strong, but heavily dependent on data connectors that most wealth advisors won’t have configured on day one. Needs FactSet and MSCI connectors properly set up to deliver real value.</p><p><strong>21. Brand Voice (by Tribe AI): B-Tier</strong> Partner-built plugin. Analyzes your existing documents, marketing materials, and conversations to distill your brand’s voice into clear, enforceable guidelines.</p><p>Give it 10 to 20 examples of your writing and it produces a brand voice guide that other plugins can reference. Useful for teams standardizing voice across multiple writers. Needs enough input material to work well.</p><p><strong>The pattern in the plugin library</strong></p><p>The first wave (January 30) targeted horizontal functions: productivity, sales, marketing, data, legal, finance. Things every company needs. That’s the wave that triggered the SaaSpocalypse.</p><p>The second wave (February 24) went vertical: investment banking, private equity, equity research, wealth management, human resources, engineering, design, operations. Industry-specific. Role-specific. The kind of depth that signals Anthropic isn’t testing the waters.</p><p>Here’s the part that should concern every software-as-a-service company: these plugins are just markdown files. The open-source repo has 2,000 stars on GitHub already. Anthropic is inviting every company to build their own. Private plugin marketplaces are now available for enterprise teams. PwC is building industry-specific plugins for regulated sectors.</p><p>Anthropic provides the model. The Model Context Protocol provides the connections. The plugins provide the domain expertise. And because plugins are just text files, no code, no infrastructure, no build steps, the barrier to creating new ones is essentially zero for anyone who can write clear instructions.</p><p>Kate Jensen, Anthropic’s head of Americas, said it at the February 24 briefing: “We expect that every knowledge worker will feel about Cowork the way engineers already feel about Claude Code: like a tool they couldn’t live without.”</p><p>JPMorgan analyst Toby Ogg put the market impact directly: software companies right now aren’t just presumed guilty until proven innocent. They’re being sentenced before trial. The evidence: a $20/month subscription doing 40% of what $150/month enterprise seats do.</p><p>Anthropic shipped 10 new plugins in 25 days. They’ll ship more next month. The S-tier plugins already work. The A-tier plugins work with moderate setup. The B-tier plugins are frameworks waiting for your company’s context.</p><p><strong>What to do now</strong></p><p>Install the Data Analysis, Productivity, and Sales plugins. They work immediately.</p><p>Then pick the plugin that matches your role and spend 30 minutes customizing its skills with your company’s context. That one session will show you the gap between a generic AI tool and a specialized one.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=eba04fb1327f" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Claude Code Vs Codex. They’re NOT the same.]]></title>
            <link>https://medium.com/@boredhead/claude-code-vs-codex-theyre-not-the-same-6cef9c90d7bc?source=rss-f3b18b8c91bd------2</link>
            <guid isPermaLink="false">https://medium.com/p/6cef9c90d7bc</guid>
            <category><![CDATA[claude-code]]></category>
            <category><![CDATA[openai]]></category>
            <category><![CDATA[claude-code-vs-codex]]></category>
            <category><![CDATA[openai-codex]]></category>
            <category><![CDATA[claude]]></category>
            <dc:creator><![CDATA[boredhead]]></dc:creator>
            <pubDate>Wed, 18 Mar 2026 19:12:06 GMT</pubDate>
            <atom:updated>2026-03-18T19:12:06.010Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*XRqWLzo4qjns4uohlng54g.png" /><figcaption>Claude Code Vs openAI Codex</figcaption></figure><p>Claude Code and Codex are not the same tool. Most teams treat them as interchangeable and configure them the same way. That’s where the problems start.</p><p>The difference isn’t the model. It’s the control plane. One persists memory across sessions and enforces rules through hooks. The other sandbox, everything, blocks the network, and resets on every run.</p><p>Same terminal. Hidden architectural split.</p><p><strong>What they are</strong></p><p>Both are terminal-native AI coding agents. Not IDE plugins. Not chatbots.</p><p>Claude Code is Anthropic’s command-line interface. Opus 4.6, 1 million token context window. Reads your filesystem directly. Ships a five-layer config stack: CLAUDE.md hierarchy, hooks, skills, Model Context Protocol servers, subagents. Persistent memory across sessions. 5.2 million VS Code installs as of February 2026.</p><p>Codex is OpenAI’s command-line interface, built in Rust. GPT-5.3-Codex and GPT-5.4. Runs inside a sandbox with the network disabled by default. Three approval modes: suggest, auto-edit, and full-auto. 4.9 million VS Code installs on the same date.</p><p>The benchmarks are close. SWE-bench Verified: Opus 4.6 at 80.8%, GPT-5.2 at 80.0%. Top five models within 1.3 points of each other. Terminal-Bench 2.0: Codex 77.3%, Opus 4.6 at 74.7%.</p><p>The difference is not the model. It’s the control plane.</p><p><strong>The config surface</strong></p><p>Claude Code layers markdown files:</p><pre>~/.claude/CLAUDE.md          # global rules (all projects)<br>./CLAUDE.md                  # project rules (per repo)<br>./src/CLAUDE.md              # subfolder overrides<br>.claude/settings.json        # permissions, MCP servers</pre><p>Plus skills (auto-detected markdown), hooks (pre/post command automation), and Model Context Protocol servers. No size limit on CLAUDE.md. Reloads every turn.</p><p>Codex uses a parallel system:</p><pre>~/.codex/instructions.md     # global rules<br>codex.md or AGENTS.md        # project rules (walks directory tree)<br>~/.codex/config.toml         # model, approval policy, sandbox</pre><p>Also supports Agent Skills (SKILL.md with optional scripts) and Model Context Protocol servers via standard input/output or streaming HTTP. Hard constraint: project_doc_max_bytes defaults to 32 KiB. Exceed it and your instructions get truncated silently.</p><p>The enforcement gap matters. Claude Code’s CLAUDE.md compliance sits around 70%. The model follows most rules, ignores some. Hooks hit 100% because they execute as shell commands, not suggestions. Codex’s enforcement comes from the sandbox itself. The model cannot violate filesystem or network restrictions regardless of what the instructions say.</p><p>Two trust architectures. Configuring one like the other produces bad results.</p><p><strong>Trust and execution models</strong></p><p>Claude Code runs trust-by-default within the permissions you set. Reads and writes your filesystem directly. You scope access through .claude/settings.json allowlists. Wider risk surface. Higher throughput.</p><p>Codex runs sandbox-first. macOS uses Seatbelt profiles. Linux uses Landlock. The network is blocked by default, even in full-auto.</p><p>The three modes:</p><ul><li>suggest: proposes changes, you apply them</li><li>auto-edit: applies file edits, asks before commands</li><li>full-auto: runs everything inside the sandbox, still no network</li></ul><p>Claude Code is an agent with guardrails. Codex is a sandbox with an approval gate.</p><p>The failure modes split accordingly. Claude Code drifts when context gets stale. After around turn 30, compaction drops critical instructions and the agent contradicts earlier decisions. Codex stalls when it needs information outside the sandbox: a dependency it can’t fetch, docs it can’t reach, an application programming interface it can’t call.</p><p>Knowing your failure mode tells you which tool fits the task.</p><p><strong>6 defaults to change on day one</strong></p><p>Claude Code:</p><ol><li>Split CLAUDE.md into layers. Global conventions in ~/.claude/CLAUDE.md. Project rules in ./CLAUDE.md. Subsystem knowledge in subfolder files. A single 400-line file causes the model to deprioritize instructions toward the bottom.</li><li>Use /clear between unrelated tasks. Mixed context causes drift. Finish the refactor, clear, then debug the test failure. Auto-memory persists what matters. Stale context does not.</li><li>Use Sonnet for simple tasks. Opus costs 1.67x more per token. Typo fixes and one-file changes don’t need that reasoning depth. Save Opus for multi-file refactors.</li></ol><p>Codex:</p><p>4. Start with auto-edit, not full-auto. Review the first 20 edits. Learn the model’s tendencies. Identify where your AGENTS.md needs more specificity before removing the gate.</p><p>5. Write a real AGENTS.md. Without project context, Codex guesses at conventions. Teams report 40–60% fewer corrections with well-configured instructions. The 32 KiB limit is generous. Use it.</p><p>6. Keep tasks atomic. The sandbox resets between runs. Multi-step chains need explicit state handoff. If the workflow requires memory of three tasks ago, use Claude Code instead.</p><p><strong>When to use which</strong></p><p>Claude Code when you need multi-file refactors, codebase exploration, memory across tasks, and Model Context Protocol orchestration. Anything where understanding full project context produces better decisions.</p><p>Codex when you need isolated bug fixes, code review with containment, strict approval workflows, or locked-down filesystem access. Tasks where starting clean is a feature.</p><p>Both together: Claude Code for architecture and planning, Codex for sandboxed execution of the plan. Agent Skills are portable across both tools and Cursor.</p><p>Decision rule: if the agent needs to remember yesterday, Claude Code. If it needs to forget everything, Codex.</p><p><strong>Shared guidelines</strong></p><p>Write your config file first. Both tools perform dramatically better with project context. This is the highest-leverage action most developers skip.</p><p>Keep instructions under 200 lines. Both re-read them every turn. Bloat dilutes the rules that actually matter.</p><p>One task per session. Context pollution is the top failure mode for both. Finish, commit, start fresh.</p><p>Review before trust. SWE-bench in the low 80s means roughly 1 in 5 tasks still produce wrong output. Verify the diff.</p><p><strong>The real starting point</strong></p><p>Most guides start with installation. That’s the wrong place to begin.</p><p>Understand which control plane you’re operating. Configure it for your codebase. Know the failure mode you’re exposed to.</p><p>Pick one. Configure it properly. Ship something this week.</p><h4>If you’ve come this far. Subscribe to the Article &amp; never miss an update.</h4><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=6cef9c90d7bc" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Context, Skills, Hooks, Subagents: How Claude Code Actually Works]]></title>
            <link>https://medium.com/@boredhead/context-skills-hooks-subagents-how-claude-code-actually-works-acdbb7baef6a?source=rss-f3b18b8c91bd------2</link>
            <guid isPermaLink="false">https://medium.com/p/acdbb7baef6a</guid>
            <category><![CDATA[anthropic-claude]]></category>
            <category><![CDATA[claude-code]]></category>
            <category><![CDATA[claude]]></category>
            <category><![CDATA[claude-ai]]></category>
            <dc:creator><![CDATA[boredhead]]></dc:creator>
            <pubDate>Mon, 16 Mar 2026 17:25:48 GMT</pubDate>
            <atom:updated>2026-03-17T01:12:16.100Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*AqZ0OTii4AX-Z0HVcyEYEw.png" /></figure><p>The thing most people get wrong early: they treat Claude Code like a smarter chatbot. It isn’t. The failures that accumulate over time, drifting context, degrading output quality, and rules that get ignored aren’t model failures. They’re architecture failures. Fix the architecture, and the model mostly takes care of itself.</p><p>Here’s how I think about it now.</p><h3>The Six-Layer Model</h3><p>Every Claude Code setup has six layers, whether you design them intentionally or not:</p><ol><li>Context (what Claude actually sees)</li><li>Skills (workflow packages loaded on demand)</li><li>Tools and Model Context Protocol servers (available actions)</li><li>Hooks (deterministic scripts attached to Claude’s actions)</li><li>Subagents (isolated Claude instances for contained work)</li><li>Verification (how you confirm something worked)</li></ol><p>Neglect any layer, and it creates pressure somewhere else. A bloated CLAUDE.md pollutes the context. Too many tools create selection noise. Skipping verification means you’re flying blind. The layers are load-bearing.</p><h3>How the Agent Loop Actually Works</h3><pre>Gather context → Take action → Verify result → [Done or loop back]<br>     ↑                    ↓<br>  CLAUDE.md          Hooks / Permissions / Sandbox<br>  Skills             Tools / MCP<br>  Memory</pre><p>Wrong information in context causes more damage than missing information. The model will confidently act on bad inputs. And without a verification step, you often won’t know something went sideways until several steps later, when untangling it is expensive.</p><p>When things break: check context loading order before blaming the model. Check your control layer before calling the agent “too aggressive.” If a long session is producing worse results, don’t tune prompts — start fresh. Stale intermediate artefacts accumulate and degrade output in ways that are hard to diagnose.</p><h3>Context: The Real Cost Structure</h3><p>The 200K context window sounds generous until you account for what’s already eating it:</p><pre>200K total context<br>├── Fixed overhead (~15-20K)<br>│   ├── System instructions: ~2K<br>│   ├── All enabled Skill descriptors: ~1-5K<br>│   ├── MCP Server tool definitions: ~10-20K  ← Largest hidden overhead<br>│   └── LSP state: ~2-5K<br>│<br>├── Semi-fixed (~5-10K)<br>│   ├── CLAUDE.md: ~2-5K<br>│   └── Memory: ~1-2K<br>│<br>└── Dynamically available (~160-180K)<br>    ├── Conversation history<br>    ├── File contents<br>    └── Tool call results</pre><p>A single Model Context Protocol server like GitHub can expose 20–30 tool definitions at ~200 tokens each. Five servers connected at once and you’ve spent ~25,000 tokens (12.5% of total) before a single message is sent. In large codebases, this is a real constraint.</p><p>The layering that works:</p><pre>Always resident    → CLAUDE.md: project contract / build commands / prohibitions<br>Path-loaded        → rules: language / directory / file-type specific<br>On-demand loaded   → skills: workflows / domain knowledge<br>Isolated loaded    → subagents: heavy exploration / parallel research<br>Never in context   → hooks: deterministic scripts / audit / blocking</pre><p><strong>On compression:</strong> The default algorithm prioritizes re-readability and tends to drop early tool outputs and file contents first. Those often contain architectural decisions you made two hours ago. They disappear quietly and then Claude makes choices that contradict them.</p><p>Fix this with explicit Compact Instructions in CLAUDE.md:</p><pre>## Compact Instructions</pre><pre>When compressing, preserve in priority order:</pre><pre>1. Architecture decisions (NEVER summarize)<br>2. Modified files and their key changes<br>3. Current verification status (pass/fail)<br>4. Open TODOs and rollback notes<br>5. Tool outputs (can delete, keep pass/fail only)</pre><p>Better still: before closing a session, have Claude write a HANDOFF.md.</p><pre>Write the current progress in HANDOFF.md. Explain what you tried, what worked, what didn&#39;t, so the next agent with fresh context can continue from just this file.</pre><p>The next session starts from that file instead of depending on compression quality. More reliable than any prompt trick.</p><p><strong>Plan Mode:</strong> Double-tap Shift+Tab. The exploration phase stays read-only and nothing gets written until you confirm the plan. For refactors and cross-module changes, this one habit prevents a class of errors where a wrong assumption gets baked into execution before you can catch it. A useful pattern: one agent drafts the plan, another reviews it before anything runs.</p><h3>Skills: Workflows, Not Templates</h3><p>A skill isn’t a saved prompt. The descriptor stays resident in context; the full body only loads when the skill is actually invoked. That distinction matters for how you design them.</p><p>Good skill descriptions specify when to use the skill, not just what’s in it. They define inputs, outputs, and stop conditions. Reference material lives in supporting files, not in SKILL.md itself. Any skill with side effects should explicitly block model auto-invocation.</p><p>Stable structure:</p><pre>.claude/skills/<br>└── incident-triage/<br>    ├── SKILL.md<br>    ├── runbook.md<br>    ├── examples.md<br>    └── scripts/<br>        └── collect-context.sh</pre><p>Three types worth having:</p><p><strong>Quality gate</strong> — runs before a release, blocks on failure:</p><pre>---<br>name: release-check<br>description: Use before cutting a release to verify build, version, and smoke test.<br>---</pre><pre>## Pre-flight (All must pass)<br>- [ ] `cargo build --release` passes<br>- [ ] `cargo clippy -- -D warnings` clean<br>- [ ] Version bumped in Cargo.toml<br>- [ ] CHANGELOG updated<br>- [ ] smoke test passes on clean env</pre><pre>## Output<br>Pass / Fail per item. Any Fail must be fixed before release.</pre><p><strong>Workflow with rollback</strong> — high-risk operations, explicit invocation only:</p><pre>name: config-migration<br>description: Migrate config schema. Run only when explicitly requested.<br>disable-model-invocation: true<br>---</pre><pre>## Steps<br>1. Backup: `cp ~/.config/app/config.toml ~/.config/app/config.toml.bak`<br>2. Dry run: `app config migrate --dry-run`<br>3. Apply: remove `--dry-run` after confirming output<br>4. Verify: all checks pass</pre><pre>## Rollback<br>`cp ~/.config/app/config.toml.bak ~/.config/app/config.toml`</pre><p><strong>Decision framework</strong> — structured evidence collection instead of guessing:</p><pre>---<br>name: runtime-diagnosis<br>description: Use when the app crashes, hangs, or behaves unexpectedly at runtime.<br>---</pre><pre>## Evidence Collection<br>1. Run health check and capture full output<br>2. Last 50 lines of application logs<br>3. Plugin or extension state</pre><pre>## Decision Matrix<br>| Symptom | First Check |<br>|---|---|<br>| Crash on startup | health output → syntax error |<br>| Rendering glitch | GPU backend / terminal capability |<br>| Config not applied | Config path + schema version |</pre><pre>## Output Format<br>Root cause / Blast radius / Fix steps / Verification command</pre><p>Descriptor length matters. Every enabled skill keeps its descriptor in context permanently.</p><pre># Inefficient (~45 tokens)<br>description: |<br>  This skill helps you review code changes in Rust projects.<br>  It checks for common issues like unsafe code, error handling...<br>  Use this when you want to ensure code quality before merging.</pre><pre># Efficient (~9 tokens)<br>description: Use for PR reviews with focus on correctness.</pre><p>Invocation strategy based on frequency:</p><ul><li>More than once per session: keep auto-invoke, optimize the descriptor</li><li>Less than once per session: disable auto-invoke, trigger manually</li><li>Less than once per month: remove it entirely, document in AGENTS.md instead</li></ul><h3>Tool Design: Optimize for Selection, Not Coverage</h3><p>Human-facing Application Programming Interfaces optimize for completeness. Agent-facing tools need to optimize for correct selection. Those are different design goals.</p><p>Practical rules: prefix names by system layer (github_pr_*, jira_issue_*), support response_format: concise / detailed, make error messages corrective rather than opaque, and avoid list_all_* patterns that push filtering work onto the model.</p><p><strong>How Anthropic learned this the hard way with questioning:</strong></p><p>Version 1 — add a question parameter to existing tools like Bash. Claude ignored it and kept going.</p><p>Version 2 — require a specific markdown format that triggers a pause. No hard enforcement, so it remained fragile.</p><p>Version 3 — a standalone AskUserQuestion tool. The tool call itself is the pause signal. Structurally impossible to skip.</p><p>If you want Claude to stop and ask, the only reliable approach is a dedicated tool. Output format conventions are too easy to skip.</p><p><strong>On search tools:</strong> Early Claude Code relied on a retrieval-augmented generation-style vector database. Fast, but required indexing and broke across environments. Worse, model adoption was poor. Switching to a grep-style tool where Claude searches directly worked better, and had a useful side effect: Claude can read a skill, follow file references, and load information progressively as needed. Progressive disclosure working correctly.</p><p>Don’t add a tool if the shell can already handle the task reliably, if the model needs static knowledge rather than external interaction, or if you haven’t validated that the description, schema, and return format are stable for model use.</p><h3>Hooks: Move Decisions Out of the Model</h3><p>The right mental model for hooks isn’t “scripts that run automatically.” It’s “things that should never depend on the model remembering to do them.”</p><p>Formatting, protected file checks, post-task notifications — these don’t require judgment. They require consistency. Hooks provide that.</p><pre>{<br>  &quot;hooks&quot;: {<br>    &quot;PostToolUse&quot;: [<br>      {<br>        &quot;matcher&quot;: &quot;Edit&quot;,<br>        &quot;pattern&quot;: &quot;*.rs&quot;,<br>        &quot;hooks&quot;: [<br>          {<br>            &quot;type&quot;: &quot;command&quot;,<br>            &quot;command&quot;: &quot;cargo check 2&gt;&amp;1 | head -30&quot;,<br>            &quot;statusMessage&quot;: &quot;Running cargo check...&quot;<br>          }<br>        ]<br>      }<br>    ],<br>    &quot;Notification&quot;: [<br>      {<br>        &quot;type&quot;: &quot;command&quot;,<br>        &quot;command&quot;: &quot;osascript -e &#39;display notification \&quot;Task completed\&quot; with title \&quot;Claude Code\&quot;&#39;&quot;<br>      }<br>    ]<br>  }<br>}</pre><p>For mixed-language projects, trigger separately by file type:</p><pre>{<br>  &quot;hooks&quot;: {<br>    &quot;PostToolUse&quot;: [<br>      {<br>        &quot;matcher&quot;: &quot;Edit&quot;,<br>        &quot;pattern&quot;: &quot;*.rs&quot;,<br>        &quot;hooks&quot;: [{<br>          &quot;type&quot;: &quot;command&quot;,<br>          &quot;command&quot;: &quot;cargo check 2&gt;&amp;1 | head -30&quot;,<br>          &quot;statusMessage&quot;: &quot;Checking Rust...&quot;<br>        }]<br>      },<br>      {<br>        &quot;matcher&quot;: &quot;Edit&quot;,<br>        &quot;pattern&quot;: &quot;*.lua&quot;,<br>        &quot;hooks&quot;: [{<br>          &quot;type&quot;: &quot;command&quot;,<br>          &quot;command&quot;: &quot;luajit -b $FILE /dev/null 2&gt;&amp;1 | head -10&quot;,<br>          &quot;statusMessage&quot;: &quot;Checking Lua syntax...&quot;<br>        }]<br>      }<br>    ]<br>  }<br>}</pre><p>Finding a compile error on edit 3 is much cheaper than finding it on edit 40. In a 100-edit session, 30–60 seconds saved per edit is 1–2 hours total. Keep output short (| head -30) so hook results don&#39;t pollute context.</p><p>Hooks aren’t a complete solution on their own. The stack that actually holds:</p><ul><li>CLAUDE.md: state the rule (“must pass tests and lint before commit”)</li><li>Skill: define how to execute it (test order, failure handling, fix steps)</li><li>Hook: enforce it deterministically on critical paths</li></ul><p>Each layer alone has gaps. Together they close them.</p><p>Don’t use hooks for: complex semantic judgments, long-running business logic, anything requiring multi-step reasoning. That’s what skills and subagents are for.</p><h3>Subagents: Isolation Over Parallelism</h3><p>A subagent is an independent Claude instance with its own context window and a restricted tool set. The value isn’t running things in parallel — it’s keeping heavy intermediate output out of your main context.</p><p>Codebase scans and test runs that generate thousands of tokens of output? Send them to a subagent. The main thread gets a summary. The garbage stays isolated.</p><p>Built-in options: Explore (read-only, runs Haiku to save cost), Plan, General-purpose, and custom.</p><p>Configuration constraints worth enforcing:</p><ul><li>tools / disallowedTools: never give a subagent the same broad permissions as the main thread</li><li>model: Haiku or Sonnet for exploration, Opus for reviews that matter</li><li>maxTurns: always set a ceiling</li><li>isolation: worktree: use this when the subagent needs to touch files</li></ul><p>For long-running bash work, Ctrl+B moves it to the background. Claude checks results later with BashOutput without blocking anything.</p><p>What subagents are bad at: tasks with strong dependencies between subtasks that require frequent sharing of intermediate state. That kind of tight coupling defeats the purpose.</p><h3>Prompt Caching: It Shapes Architecture</h3><p>This gets less attention than it deserves. Cache hit rate directly affects cost, latency, and rate limits. It should inform how you structure everything above it.</p><p>Caching works by prefix matching — everything from the start of the request to each cache_control breakpoint gets cached. Claude Code&#39;s prompt order:</p><pre>1. System Prompt → Static, locked<br>2. Tool Definitions → Static, locked<br>3. Chat History → Dynamic, comes after<br>4. Current user input → Last</pre><p>Common ways people accidentally break caching: putting timestamps in the system prompt, shuffling tool definition order non-deterministically, adding or removing tools mid-session. Dynamic content like the current time belongs in a later message — not the system prompt.</p><p><strong>Don’t switch models mid-session.</strong> Cache is model-specific. If you’ve accumulated 100K tokens of conversation with Opus and switch to Haiku for a quick question, you pay to rebuild the entire cache for Haiku. It’s more expensive than staying on Opus. If you need to switch, do it via subagent handoff: Opus prepares a summary message, and the new model starts from that.</p><p><strong>How compaction actually works:</strong> Claude Code forks a summarisation call over the existing conversation (which itself benefits from caching), compresses the turns into a shorter summary, and preserves the system prompt, tool definitions, and referenced files. The session continues with freed space.</p><p>Plan Mode doesn’t change the underlying tool prefix. That’s intentional — switching to a read-only toolset would break cache reuse every time you enter and exit planning. The same prefix stays in place.</p><p><strong>defer_loading:</strong> Rather than including every full tool definition in every request, Claude Code keeps lightweight stubs in the stable prefix and loads full schemas only when a tool is selected. Avoids both the cost of full definitions and the cache instability of adding and removing tools dynamically.</p><h3>Verification: Define Done Before You Start</h3><p>The question isn’t whether Claude finished. It’s whether what it produced is correct, and whether you can roll it back if it isn’t.</p><p>Verifier levels:</p><ul><li>Lowest: command exit codes, lint, typecheck, unit tests</li><li>Middle: integration tests, screenshot comparison, contract tests, smoke tests</li><li>Higher: production log verification, monitoring metrics, manual review checklists</li></ul><p>Define acceptance criteria explicitly in your prompt, in the relevant skill, and in CLAUDE.md:</p><pre>## Verification</pre><pre>For backend changes:</pre><pre>- Run `make test` and `make lint`<br>- For API changes, update contract tests under `tests/contracts/`</pre><pre>For UI changes:</pre><pre>- Capture before/after screenshots if visual</pre><pre>Definition of done:</pre><pre>- All tests pass<br>- Lint passes<br>- No TODO left behind unless explicitly tracked</pre><p>My test for whether a task is ready for autonomous execution: can I clearly describe what a correct result looks like before Claude starts? If not, the task isn’t ready. A capable model with no acceptance criteria still has no reliable way to know when it’s done.</p><h3>Commands to Use Constantly</h3><p>The goal is active context management. Don’t wait for the system to handle it.</p><p><strong>Context:</strong></p><pre>/context   # Inspect token consumption, including MCP and file-read ratios<br>/clear     # Reset the session; useful when the same issue has already been corrected twice<br>/compact   # Compress while retaining key points; works best with Compact Instructions<br>/memory    # Confirm which CLAUDE.md actually got loaded</pre><p><strong>Governance:</strong></p><pre>/mcp           # Manage MCP connections, check token costs, disconnect idle servers<br>/hooks         # Manage hooks; this is a key control-plane entry point<br>/permissions   # View or update permission whitelist<br>/sandbox       # Configure sandbox isolation, essential for high-automation scenarios<br>/model         # Switch models: Opus for deep reasoning, Sonnet for routine, Haiku for quick exploration</pre><p><strong>Session control:</strong></p><pre>claude --continue               # Resume the latest session in the current directory<br>claude --resume                 # Open selector to resume historical session<br>claude --continue --fork        # Fork from an existing session to try a different approach<br>claude --worktree               # Create isolated git worktree<br>claude -p &quot;prompt&quot;              # Non-interactive mode for CI, pre-commit, or other scripts<br>claude -p --output-format json  # Structured output that scripts can consume directly</pre><p>A few less obvious ones worth knowing:</p><p>/simplify — quick pass over recently modified code, focused on reuse and efficiency. Run it right after changing logic, not as an afterthought.</p><p>/rewind — returns to an earlier checkpoint and re-summarises from there. Not an undo. Useful when Claude went deep down the wrong path, and you want to keep the early work but discard what came after.</p><p>/btw — side question without interrupting the main task. Fine for quick comparisons. Not for anything that requires reading files or making tool calls.</p><p>claude -p --output-format stream-json — real-time JSON event stream. Useful for monitoring long-running tasks or piping output into your own tooling.</p><p>/insight — asks Claude to analyse the current session and surface what should be added to CLAUDE.md. Run it after a productive stretch. It catches patterns you&#39;d otherwise miss.</p><p><strong>Double-tap Escape</strong> brings back your previous input for editing. Faster than restarting when your last message was underspecified.</p><p><strong>Session history is local.</strong> Everything lives under ~/.claude/projects/ as .jsonl files, organised by project path. To find prior work: grep -rl &quot;keyword&quot; ~/.claude/projects/.</p><h3>CLAUDE.md: A Contract, Not Documentation</h3><p>Every entry in CLAUDE.md should answer one question: Does Claude need this in every single session? If not, it belongs somewhere else.</p><p>Start empty. Add entries only when you catch yourself repeating the same instruction. Use # to append the current conversation directly, or tell Claude, &quot;add this to the project&#39;s CLAUDE.md.&quot;</p><p><strong>Include:</strong></p><ul><li>Build, test, lint, run commands</li><li>Directory structure and module boundaries</li><li>Code style and naming constraints that aren’t obvious from the repo</li><li>Environment dependencies and known pitfalls</li><li>Hard prohibitions (the NEVER list)</li><li>Compact Instructions</li></ul><p><strong>Don’t include:</strong></p><ul><li>Background context or introductions</li><li>Full Application Programming Interface documentation</li><li>Principles like “write clean code” that Claude can’t act on concretely</li><li>Anything Claude can infer from reading the codebase</li><li>Reference material for infrequent tasks (put that in skills)</li></ul><p>Template that holds up in practice:</p><pre># Project Contract</pre><pre>## Build And Test</pre><pre>- Install: `pnpm install`<br>- Dev: `pnpm dev`<br>- Test: `pnpm test`<br>- Typecheck: `pnpm typecheck`<br>- Lint: `pnpm lint`</pre><pre>## Architecture Boundaries</pre><pre>- HTTP handlers live in `src/http/handlers/`<br>- Domain logic lives in `src/domain/`<br>- Do not put persistence logic in handlers<br>- Shared types live in `src/contracts/`</pre><pre>## Coding Conventions</pre><pre>- Prefer pure functions in domain layer<br>- Do not introduce new global state without explicit justification<br>- Reuse existing error types from `src/errors/`</pre><pre>## Safety Rails</pre><pre>### NEVER</pre><pre>- Modify `.env`, lockfiles, or CI secrets without explicit approval<br>- Remove feature flags without searching all call sites<br>- Commit without running tests</pre><pre>### ALWAYS</pre><pre>- Show diff before committing<br>- Update CHANGELOG for user-facing changes</pre><pre>## Verification</pre><pre>- Backend changes: `make test` + `make lint`<br>- API changes: update contract tests under `tests/contracts/`<br>- UI changes: capture before/after screenshots</pre><pre>## Compact Instructions</pre><pre>Preserve:</pre><pre>1. Architecture decisions (NEVER summarize)<br>2. Modified files and key changes<br>3. Current verification status (pass/fail commands)<br>4. Open risks, TODOs, rollback notes</pre><p>After fixing a mistake, tell Claude: “Update your CLAUDE.md so you don’t make that mistake again.” It’s reasonably good at writing its own rules. Review the file occasionally anyway — stale constraints add noise without adding value.</p><h3>Project Layout Reference</h3><pre>Project/<br>├── CLAUDE.md<br>├── .claude/<br>│   ├── rules/<br>│   │   ├── core.md<br>│   │   ├── config.md<br>│   │   └── release.md<br>│   ├── skills/<br>│   │   ├── runtime-diagnosis/     # Uniformly collect logs, state, dependencies<br>│   │   ├── config-migration/      # Config migration rollback protection<br>│   │   ├── release-check/         # Pre-release validation, smoke test<br>│   │   └── incident-triage/       # Production incident triage<br>│   ├── agents/<br>│   │   ├── reviewer.md<br>│   │   └── explorer.md<br>│   └── settings.json<br>└── docs/<br>    └── ai/<br>        ├── architecture.md<br>        └── release-runbook.md</pre><p>Global constraints in CLAUDE.md, path-specific rules in rules/, task workflows in skills/, architectural detail in docs/ai/. Keep personal defaults in ~/.claude/ and project-specific config in each project&#39;s .claude/. Cross-project pollution is real.</p><h3>The Actual Shift</h3><p>Most people hit a wall with Claude Code at some point. Output quality drops. Rules get ignored. Sessions drift. The instinct is to fix the prompts.</p><p>The prompts usually aren’t the problem.</p><p>The constraint that actually matters: before handing a task to Claude for autonomous execution, you need a clear definition of done. Which commands must pass, what the output should look like, and how you’ll verify it. Without that, there’s no signal for Claude or for you that the work is actually finished.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=acdbb7baef6a" width="1" height="1" alt="">]]></content:encoded>
        </item>
    </channel>
</rss>