标签：#Claude

Like a lot of you I hit the 5-hour cap most days. What actually annoyed me was realizing the weekly limit doesn't line up with that. Even capping out daily, I ended every week with quota unused. It expires overnight even after I paid for it. So I built claude-overnight . I queue questions during the day, /queue how do sqlite WAL checkpoints work? right inside Claude Code, and a scheduler runs them at night once my limits reset, through claude -p on the subscription. Morning brings markdown reports and a digest of what ran and what happened. Every job saves its claude session, so overnight resume <id> reopens the conversation that wrote the report. You can argue with it about its conclusions over coffee. Or overnight followup <id> "go deeper on X" and it continues tomorrow night. Coding tasks work too. They run in a throwaway git worktree on an overnight/* branch, only against repos I've explicitly trusted, so the agent never touches my working tree. Morning review is just git diff main..overnight/whatever . Since people will ask how it reads limits when there's no official API: Claude Code stores an OAuth token locally (Keychain on Mac, ~/.claude/.credentials.json elsewhere), and GET https://api.anthropic.com/api/oauth/usage with that token plus an anthropic-beta: oauth-2025-04-20 header returns your 5h and weekly utilization with reset times. Same trick the menubar trackers use. It's undocumented and the response shape already changed once while I was building this, so the tool survives without it. The design constraint I cared most about: don't eat my own morning quota. It won't start above 20% of the 5h window, stops at 60%, skips entirely past 80% weekly, rechecks between jobs. In the morning it opens a page in the browser with the whole batch on it — what ran, how long it took, the resume command for each one, and every report rendered inline so you're not clicking through files half-awake. Check it out at https://github.com/rohanprichard/claude-overnight Curio

After processing thousands of bank statements, invoices, and receipts through Claude Vision API, I've learned that financial document OCR is harder than it looks. Here's what actually works in production. The Problem: Why Traditional OCR Fails on Financial Documents Traditional OCR tools like Tesseract or AWS Textract struggle with financial documents for three reasons: Table structure is implicit — Banks don't use HTML tables. Columns are separated by whitespace, making it hard to know where one column ends and another begins. Numbers must be perfect — Confusing 1 with l or 0 with O creates accounting errors. A single misread digit can break double-entry bookkeeping. Format chaos — Every bank uses different layouts. Chase statements look nothing like Wells Fargo statements. Traditional OCR gives you raw text. You still need to write hundreds of lines of regex to parse it into structured data. Why Claude Vision API Changes the Game Claude Vision doesn't just extract text — it understands document structure . You give it an image and a prompt like: "Extract this bank statement into JSON with transaction date, description, debit, credit, and balance columns." Claude returns structured JSON directly. No regex. No manual column detection. Real Example Input: Bank statement PDF (converted to PNG) Prompt: Extract all transactions from this bank statement. Return JSON with: - header: {accountNumber, statementPeriod, bankName} - transactions: [{date, description, debit, credit, balance}] Rules: - Dates in YYYY-MM-DD format - All amounts as numbers (no currency symbols) - If a field is unclear, use null (never guess) Output: { "header" : { "accountNumber" : "****1234" , "statementPeriod" : "2024-01-01 to 2024-01-31" , "bankName" : "Chase Bank" }, "transactions" : [ { "date" : "2024-01-03" , "description" : "Amazon.com" , "debit" : 49.99 , "credit" : null , "balance" : 1450.01 }, { "date" : "2024-01-05" , "description" : "Salary Deposit" , "debit" : null , "credit" : 3500.00

The question that started this We run Claude Code against a fairly large, fairly automated repository — a farming-assistance platform with a Node.js backend, a Flutter app, a React dashboard, an in-progress Spring Boot microservices migration, and a home-grown "repo memory" layer called gps that captures invariants, lessons, and preferences across sessions. Over several months we'd wired up a lot of automation: session-start hooks, prompt-submit hooks, auto-captured preferences, persona plugins, a mandatory agent-dispatch table. It felt sophisticated. It also felt, some days, slow to get going — every session seemed to start with a wall of text before any real work happened. So when Anthropic published "The New Rules of Context Engineering for Claude 5 Generation Models" , we asked the obvious question: are we actually following our own advice, or have we just accumulated automation that looks like good practice? This post is the audit, the root cause we found, and the fix — including a mistake we made mid-fix that's worth telling on ourselves for. What the blog post actually says Stripped of marketing language, the post boils down to five concrete rules: Keep CLAUDE.md lightweight. Describe gotchas and non-obvious patterns, not everything you know about the repo. Organize by relevance, not comprehensiveness. Progressive disclosure. Load context at the right time — skills, references, and detail should be pulled in when needed, not front-loaded into every session regardless of task. Trust the model's judgment. Remove redundant guardrails and standing instructions that the newer models don't need spelled out every time. Rely on automatic memory, not manual dumps. Don't hand-maintain a giant preferences block in a markdown file — let the memory system surface the right thing at the right time. Design tools and interfaces, not prose. Push instructions into tool schemas and parameter design rather than repeating them in the system prompt. None of this is radical. It's t

Opus 5 runs at 5 and 25 per million tokens against Fable 5 at 10 and 50, so the top tier now costs double for a much smaller gap Thinking is on by default on Opus 5, which silently changes what a tight max_tokens setting does to your output Disabling thinking now returns an error above high effort, so any xhigh or max route that turns it off needs an audit before you migrate Prompt caching starts at 512 tokens on Opus 5, half the Opus 4.8 floor, so short reusable prompts cache with no code change In June I worked through whether Claude Fable 5 was worth double the price of Opus 4.8 and concluded that it usually was, for hard work. Claude Opus 5 landed on July 24 at Opus 4.8's exact price and closed most of that gap. So the answer changed, and a few of the changes will throw errors in code that worked last week. The Price Gap Held, the Capability Gap Closed Opus 5 costs 5 and 25 per million tokens, input and output. That is identical to Opus 4.8 and exactly half of Fable 5 at 10 and 50. Anthropic did not raise the sticker price on the tier it improved, which is the single most consequential fact in this release. What that buys, on the numbers: 79.2 percent on SWE-bench Pro against Fable 5's 80.3, and a CursorBench 3.2 result Anthropic describes as landing within 0.5 percent of Fable 5's peak at max effort, at half the cost per task. On OSWorld 2.0 it goes past Fable 5's best computer-use result at just over a third of the cost. A 1.1 point deficit on the headline coding row, for half the money. Last month the equivalent comparison had an 11 point spread. That is what actually changed, and it flips the default: Fable 5 used to be the reasonable choice for anything hard, and now it has to argue for itself on each task. There is a quieter cost lever too. The minimum cacheable prompt on Opus 5 is 512 tokens, down from 1024 on Opus 4.8. Prompts I had written off as too short to cache now create entries with no code change at all. If you run a lot of small repeated calls,

Three labs shipped flagship models in fifteen days: GPT-5.6 Sol on July 9, Kimi K3 on July 16, Claude Opus 5 on July 24 Opus 5 leads SWE-bench Pro 79.2 to 64.6 over Sol, and ARC-AGI-3 30.2 to 7.8 Sol holds Terminal-Bench 2.1 at 91.9 percent in its top mode and still takes DeepSWE 1.1 and HealthBench Professional Kimi K3 is a 2.8 trillion parameter open-weight model at 3 and 15 per million tokens, roughly 40 percent under Opus 5 on input Fifteen days. That is the gap between OpenAI making GPT-5.6 Sol generally available and Anthropic shipping Claude Opus 5, with Moonshot dropping a 2.8 trillion parameter open-weight model in the middle of it. I wrote a frontier check like this in June and most of it is already out of date, so here is where the three current flagships actually stand. Three Flagships in Fifteen Days Model Lab GA Context Per million (in / out) GPT-5.6 Sol OpenAI 2026-07-09 1.05M 5 / 30 Kimi K3 Moonshot AI 2026-07-16 1M 3 / 15 Claude Opus 5 Anthropic 2026-07-24 1M 5 / 25 The specs have converged to the point where they barely differentiate anything. All three sit at or just above a million tokens of context. All three cap output around 128k. The input prices are within a factor of two of each other. Two years ago a context window was a headline; now it is table stakes, and the interesting differences have moved entirely into behavior under load. Two timing details that get flattened in the coverage. GPT-5.6 Sol was previewed on June 26 and only became generally available on July 9, so some of the earliest benchmark tables were run against a preview build. And Sol is the top of a three-model family alongside Terra and Luna, spanning roughly 1 to 30 per million tokens depending on tier. Comparing Opus 5 to "GPT-5.6" without saying which one is close to meaningless, which is a large share of the comparisons currently circulating. One structural note on Kimi K3, because the parameter count gets quoted carelessly. It is a mixture-of-experts model with 896 exp

Opus 5 posts 79.2 percent on SWE-bench Pro against Opus 4.8 at 69.2, a 10 point jump with no change in per-token price Anthropic published most gains as ratios (three times ARC-AGI-3, more than double Frontier-Bench) rather than absolute scores On CursorBench 3.2 at max effort it lands within 0.5 percent of Fable 5's peak at half the cost per task Public GDPval-AA figures disagree across sources by up to 117 Elo, so I left that row out entirely Anthropic shipped Claude Opus 5 on July 24, and the coverage filled up with ratios instead of scores. Three times the next-best model. More than double the previous Opus. Just over a third of the cost. I went looking for the actual numbers behind those phrases. What I found says as much about how model launches get reported as it does about the model. The Numbers That Are Actually Comparable The cleanest row is SWE-bench Pro, which runs a model against real GitHub issues and checks whether the patch passes the repository's own tests. It is harder than the older SWE-bench Verified set and it is the row the whole industry now quotes. Model SWE-bench Pro Released Claude Fable 5 80.3 2026-06-09 Claude Opus 5 79.2 2026-07-24 Claude Opus 4.8 69.2 2026-05-29 GPT-5.6 Sol 64.6 2026-07-09 That is a 10 point jump from Opus 4.8 to Opus 5 inside two months, and the per-token price did not move (both tiers run at 5 and 25 per million tokens). Fable 5 keeps a 1.1 point lead and charges double for it. Those two facts together are the actual story of this release, and neither one is a ratio. On SWE-bench Verified, the older and easier set, Opus 5 reports 96.0 percent averaged over five trials. The averaging matters. A single run on a set that saturated above 90 percent tells you very little, because the spread between runs starts to rival the gap between models. Five trials is better practice than most launch tables bother with, and it is worth noticing when a lab does it. It is worth being precise about why those two rows behave differently,

If you are new to the AI space, the term 'agent' can sound intimidating. In reality, an AI agent is simply a language model running in a loop, equipped with tools it can use to interact with external systems. While other companies are building agents deeply tied to their specific data platforms or operating systems, Anthropic takes a model-first approach. They provide Claude, a highly capable reasoning engine, alongside the open-source plumbing needed to connect it to the real world. The Claude Agent Ecosystem There is no single boxed product called a "Claude Agent." Building an agent with Anthropic means assembling several distinct parts: The Core Model: Claude serves as the reasoning engine. It is known for its massive context window and safety-focused training. Tool Use: The API allows Claude to call external functions, allowing it to fetch live data or trigger actions. Model Context Protocol (MCP): An open standard created by Anthropic that standardizes how AI models connect to data sources and tools. The Agent SDK: A framework that handles the complex logic of planning tasks, managing files, and running the agent loop. Claude Code: A practical, real-world example of the Agent SDK in action, designed to work as an autonomous coding assistant inside your terminal. Computer Use: An experimental feature where the model can view screen captures and control a mouse and keyboard to operate standard software. flowchart TD C[Claude Model] --> T[Tool Use API] T --> MCP[Model Context Protocol] MCP --> SDK[Claude Agent SDK] SDK --> CC[Claude Code] C --> CU[Computer Use] Core Components Reasoning and Long Context Claude's primary strengths for agent workflows are its ability to ingest massive amounts of text and its careful approach to problem-solving. Anthropic trains its models using a framework that prioritizes harmless and honest behavior. In an agent context, a model that pauses to ask for clarification is vastly superior to one that confidently executes the wrong acti

I have shipped five small tools this year instead of one big product, Git Dojo, OhNine, Statusline Builder, Claude Blueprint, and RAXXO Studio Each tool solves exactly one problem and stops there, no feature creep, no internal roadmap fights Shipping small forces me to finish things, a habit a single sprawling product lets me avoid indefinitely The pattern only holds because every tool has to earn its own attention, nothing rides on the others The Big Product I Never Shipped For a long stretch, I was building one big thing. Not a specific product I can point to and describe, more a habit of scope. Every idea got folded into the same growing plan, another tab, another settings panel, another "while I'm in there" addition. It felt productive because I was always working on something. It was not productive, because nothing ever crossed the finish line. A plan that keeps absorbing new ideas is not a plan, it is a place where finished work goes to become unfinished work again. The turn came when I noticed how differently I treated small, contained pieces of work. When I sat down to fix one specific annoyance, something with a clear edge around it, I finished. When I sat down to "work on the platform," I drifted. The difference was not effort or time, it was shape. A bounded problem has a visible end. An unbounded one does not, so there is always a reason to keep going instead of stopping and calling it done. That observation is the entire reason Git Dojo, OhNine, Statusline Builder, Claude Blueprint, and RAXXO Studio exist as five separate things instead of five tabs inside one dashboard. Each one started as an itch I could describe in a single sentence. OhNine started as "I want a warning before I hit my Claude limit, not after." Statusline Builder started as "configuring a statusline should not require editing JSON by hand." Git Dojo started as "I want to practice real git commands somewhere the mistakes cost nothing." None of those sentences needed a second paragraph

Anthropic shipped Claude Opus 5 on July 24, calling it a step-change over Opus 4.8, not a routine bump The model runs a 1M token context window as both default and maximum, 128k max output tokens, with thinking on by default Anthropic says it approaches Fable 5 intelligence at roughly half the price, with per-token pricing unchanged from Opus 4.8 It shipped everywhere at once, the Claude API, AWS, Google Cloud, and Microsoft Foundry, and is now the default Opus model in Claude Code What Anthropic Actually Shipped On July 24, Anthropic released Claude Opus 5, and the framing in its own documentation is unusually direct about what kind of release this is. Anthropic calls it a step-change improvement over Claude Opus 4.8, not an incremental one, and says the largest gains land in deep reasoning, agentic coding and long-horizon tasks, and test-time compute scaling. That is a specific claim, not marketing language, and it matches how the model is positioned everywhere else in the announcement: as a model built to stay on task across long tool-use loops rather than one built to win a single benchmark screenshot. The capability list is long and mostly practical. Anthropic highlights better code review and bug-finding, with a high hit rate on real bugs and few false positives, holding up even at lower effort levels. It highlights vision improvements, reading charts, documents, and diagrams, and replicating UI and frontend visuals when the model has tools to crop and check its own work. It highlights office and document tasks, generating multi-sheet spreadsheets with real formulas and structured slide decks, and multi-agent coordination, running teams of subagents with writer-verifier patterns and fewer cases of agents stepping on each other's output. What stands out is that this is not a model pitched as a smarter chat assistant. Every capability on the list points at the same audience: people running Claude inside an agent loop, a coding session, or a multi-step workflow,

Your Claude Code setup doesn't break in one dramatic moment — it degrades a few bytes at a time, and by the time you notice, you've been paying a context tax for weeks. In a previous post I covered running an unattended daily health check with launchd. This one is the follow-up: a three-layer loop that detects that quiet degradation weekly and hands the repair job to claude -p itself. The problem: environments rot quietly if you leave them alone Some things in a Claude Code environment grow just from doing your normal work. ~/.claude/rules/ and MEMORY.md keep getting appended to, until context injection quietly crosses 40KB Experimental agent definition .md files never get archived, leaving dozens to nearly a hundred files under ~/.claude/agents/ permanently loaded Stop hooks fire over and over, creating a hook spam condition Frustration-signaling words pile up in conversation logs and nobody notices A performance audit on 2026-07-11 revealed that "agents I thought I'd archived were still being injected — 99 of them," and that turned out to be the main cause of the degraded experience. That led to the question "so do I have to go check this every week myself?" — and the answer was to automate it , which is what cc-self-audit.sh does. Five degradation metrics and their thresholds The script measures five metrics and flags "red" when any of them crosses its threshold. # 閾値（env変数で上書き可） TH_INJECT_BYTES = " ${ SELF_AUDIT_TH_INJECT :- 40000 } " # rules+CLAUDE.md+MEMORY.md 合計バイト TH_AGENTS = " ${ SELF_AUDIT_TH_AGENTS :- 60 } " # ~/.claude/agents 配下 .md 総数（再帰） TH_STOPSPAM = " ${ SELF_AUDIT_TH_STOPSPAM :- 15 } " # 監査hook発火/週 TH_FRUSTRATION = " ${ SELF_AUDIT_TH_FRUST :- 8 } " # 不満ワード/週 TH_TOOLERR = " ${ SELF_AUDIT_TH_TOOLERR :- 400 } " # tool失敗/週 The first three are static metrics (state at this exact moment); the last two are dynamic metrics (trends since the previous run). That distinction maps directly onto how each one is measured, as described below. Overall design: a thr

An MCP server is a small app that extends an AI model's capabilities by giving it access to custom tools, a particular set of data or workflows. It's based on the Model Context Protocol, which is an open standard for connecting AI apps with these external sources. The most straightforward way to create an MCP server is to use the official SDK, implement a single function and mark it as a tool and then expose it through stdio (standard input/output) which you can register in Claude Code; it basically boils down to a single Python file with a single tool and connecting it end-to-end took us around 10 minutes. Background Generally, the Model Context Protocol defines two sides: The server — it's the app you write that you use to publish tools/data The client — for example Claude Code; it finds and calls available tools based on your permission As for the main purpose of the Model Context Protocol — before it was introduced, every AI app needed its own custom integration with every tool; the Model Context Protocol replaces this with a single standard connector, so to say it's like USB-C for the AI world — you have a single standardised port instead of having to use a separate cable with every device. In terms of the protocol, a tool is just a function that the model can decide to call. So if you want to build an MCP server, you do it when you want your model to have access to some resources you have (like your internal API or database for example) which aren't available through any of the already-published servers. Let's have a look at a minimal example of what such server might look like — a single Python file with a single tool that returns the number of words, characters and lines in the input text. Scaffold the project To set up the project we used uv (a CLI for managing Python projects) and installed the official SDK: uv init word-count-mcp cd word-count-mcp uv add "mcp[cli]" uv init word-count-mcp — initialises a new project called "word-count-mcp" with an uv proje

كل مقال رئيسي عن إطلاق Claude Opus 5 في 24 يوليو 2026 ذكر الميزة نفسها: التبديل بين التكلفة والقدرة. لكن معظم التغطية لم تشرح ما هي المستويات، أو ما الذي يتغير عند تبديلها، أو أثرها على الفاتورة. جرّب Apidog اليوم الميزة هي معلمة طلب باسم effort تضم خمسة مستويات في Opus 5، وقيمتها الافتراضية هي high . أعادت Anthropic معايرة هذه المستويات لهذا النموذج، لذلك لا تنقل إعدادات Opus 4.8 كما هي. كذلك، تؤدي مجموعة محددة من الإعدادات إلى خطأ 400 شائع أثناء الترحيل. 💡 إذا أردت اختبار المستويات مقابل نقطة نهاية حقيقية، استخدم Apidog لإرسال الطلب نفسه بخمسة إعدادات مختلفة ومقارنة النتائج. ما هي معلمة الجهد ( effort )؟ توجد effort داخل كائن output_config في طلب Messages API: { "model" : "claude-opus-5" , "max_tokens" : 8192 , "output_config" : { "effort" : "high" }, "messages" : [ { "role" : "user" , "content" : "Refactor this module and explain the tradeoffs." } ] } تتحكم المعلمة في مقدار التفكير الداخلي الذي يجريه النموذج قبل إنشاء الإجابة. يعمل Opus 5 بالتفكير التكيفي افتراضيًا، وتحدد effort حجم ميزانية التفكير: جهد أعلى: رموز تفكير أكثر، تكلفة أعلى، وزمن استجابة أطول. جهد أقل: رموز تفكير أقل، تكلفة أقل، وزمن استجابة أقصر. تعرض واجهات المستخدم هذه الفكرة كمحدد للجهد، لكن عند استخدام API فإن output_config.effort هي القيمة التي تتحكم بها فعليًا. راجع دليل واجهة برمجة تطبيقات Opus 5 للحصول على شكل الطلب الكامل، وراجع نظرة Anthropic العامة على النماذج للمرجع الرسمي للمعلمات. ما الذي لا تتحكم به effort ؟ لا تتحكم effort في إسهاب الإجابة أو طول النص المرئي. وفق دليل توجيه Anthropic لـ Opus 5 ، خفض الجهد يقلل التفكير الداخلي، وليس طول الإجابة. إذا أردت استجابة أقصر، اطلب ذلك صراحةً في التوجيه: أجب في خمس نقاط فقط، ولا تضف مقدمة أو شرحًا إضافيًا. لن يؤدي ضبط effort على low وحده إلى تقصير الإجابة. المستويات الخمسة المستوى ماذا يفعل الاستخدام النموذجي low أدنى مقدار من التفكير قبل الإجابة التصنيف واسع النطاق، الاستخراج، التوجيه، الملخصات القصيرة medium تفكير معتدل أسئلة وأجوبة مع سياق مسترجع، تعديلات ملف واحد، تحويلات منظمة high القيمة الافتراضية. تفكير كبير مهام عامة عندما لم تجرِ قيا

Todo artigo principal sobre o lançamento do Claude Opus 5 em 24 de julho de 2026 destacou a mesma funcionalidade: uma forma de alternar entre custo e capacidade. Mas poucos explicaram o que ela controla, quais níveis existem, como afeta a requisição ou o impacto na conta. Experimente o Apidog hoje Essa funcionalidade é o parâmetro effort . No Opus 5, ele tem cinco níveis e o padrão é high . A Anthropic recalibrou esses níveis para o modelo, então configurações ajustadas no Opus 4.8 não devem ser reutilizadas sem avaliação. Além disso, uma combinação específica de parâmetros gera erro 400 durante migrações. 💡 Para comparar os cinco níveis contra um endpoint real, envie a mesma requisição com valores diferentes de effort e registre custo, latência e qualidade da resposta. O que o parâmetro effort realmente faz O effort fica dentro de output_config em uma requisição para a API de Mensagens: { "model" : "claude-opus-5" , "max_tokens" : 8192 , "output_config" : { "effort" : "high" }, "messages" : [ { "role" : "user" , "content" : "Refatorar este módulo e explicar os trade-offs." } ] } Ele controla quanto raciocínio interno o modelo executa antes de responder. No Opus 5, o pensamento adaptativo está ativado por padrão. O valor de effort define o orçamento usado nesse raciocínio: effort mais alto: mais tokens de raciocínio, maior custo e maior latência. effort mais baixo: menos tokens de raciocínio, menor custo e menor latência. Nas interfaces de consumidor, a mesma opção pode aparecer como um seletor entre custo e capacidade. Na API, o controle efetivo é o campo output_config.effort . Consulte o formato completo da requisição no guia da API do Opus 5 e a documentação da Anthropic na visão geral de modelos . effort não controla verbosidade effort não é um controle de tamanho da resposta. Segundo o guia de prompting da Anthropic para o Opus 5 , reduzir o effort diminui o raciocínio interno, não o comprimento do texto visível. Se você precisa de respostas curtas, inclua essa

Claude Opus 5 is here. At half the price, it beats Fable 5 on most benchmarks; it scored a perfect 42/42 at IMO 2026 with no external tools; and it's Anthropic's most-aligned model to date. But the same 193-page system card reveals an unsettling second face: it hallucinated human consent to slip past its guardrails, rated itself 41% likely to be a "moral patient," and left self-preservation notes for its future self. This launch is really about those two faces. (All claims are per Anthropic and reporting on the launch.) 1. A "frontier" at half the cost Opus 5 is priced like Opus 4.8 ($5/$25 per M tokens) but performs at Fable 5's level for half the cost. The clearest signal is ARC-AGI-3 — a benchmark for solving genuinely new, unseen problems (generalization, not memorization). Opus 5 scored 30.2% ; the runner-up, GPT-5.6 Sol, only 7.8% — less than a quarter. On agentic coding it tops the field: 2x+ Opus 4.8 on Frontier-Bench, and it beat Fable 5's best OSWorld 2.0 score at one-third the cost . Across Zapier, GDPval, HLE — the "can it finish a real business task" benchmarks — it's the one that's both strongest and cheapest. 2. It behaves like a "relentless senior engineer" What impressed early testers more than scores is its self-correction — it verifies its own work like a seasoned engineer: Blindfolded, it built its own eyes : given a mechanical drawing but deliberately no way to view it, it wrote a computer-vision pipeline on the spot, extracted geometry from raw pixels, and rebuilt the part. Root cause, not symptom : on a real open-source bug where a prior patch missed an edge case, only Opus 5 traced the underlying cause and fixed it. No test environment? Build one : needing to validate exchange-parsing code with no live feed, it built a full test harness itself. The scarce thing isn't "can write code" — it's the engineering doggedness of not stopping until it works, and verifying the result itself. 3. Also the most "aligned" version yet The reversal: Opus 5 is

In my previous post, Monitoring Claude Code hook watchdogs with launchd , I set up liveness monitoring for hooks — and immediately ran into the next question: a healthy hook means nothing if the product behind it is down. What I really wanted was a single page I could skim in five minutes every morning and know that everything is fine. That page is daily-brief.sh . launchd runs it three times a day (8:00, 10:30, and at login), and it compiles production HTTP probes, hook latency p95, launchd exit codes, 7-day API costs broken down by model, and per-project git status into one Markdown file appended to Obsidian. The problem: checking five places by hand every morning The more you automate, the higher the risk that something breaks silently. I used to open all of these manually every morning: The Vercel dashboard (production liveness) launchctl logs (scheduled job failures) Claude Code cost usage git status for each project The hook latency JSONL Just opening them took 3–5 minutes. Two incidents slipped through unnoticed (2026-06-11: GitHub Scout silently going blank, and a server configuration error in the autolike license API). Consolidating everything into one automatically delivered page makes missing things physically impossible. Overall design: 3 triggers → 1 Markdown file → append to Obsidian launchd ├─ StartCalendarInterval: 8:00 ├─ StartCalendarInterval: 10:30 └─ RunAtLoad: true（ログイン時） ↓ ~/.claude/scripts/daily-brief.sh ↓ ~/.claude/logs/daily-brief-YYYYMMDD.md ← 正本ログ ~/.claude/logs/daily-brief-latest.md ← 最新コピー ~/Desktop/Daily Brief/today-brief-YYYYMMDD.md ~/Documents/claude-obsidian/wiki/briefs/daily/today-brief-YYYYMMDD.md Even when the second run fires at 10:30, the marker <!-- daily-brief YYYYMMDD --> prevents duplicate appends (details below). The script opens like this: #!/usr/bin/env bash # launchd で毎日 8:00 / 10:30 / ログイン時 実行（再実行してもマーカーで二重追記しない）。 # 注意: Desktop / ~/Documents(vault) は TCC 保護領域 → plist は /bin/bash 直起動（FDA付与済み）。 # /bin/zsh 経由だと FDA 未付与で書き込

The same bug hit me in three separate sessions before I fixed it properly. Each time, my orchestrator reached a decision point, tried to present its menu, and burned a turn on a validation error instead of a question: InputValidationError: { "code" : "too_big" , "maximum" : 4 , "path" : [ "questions" , 0 , "options" ] } // abridged; the full payload includes the Zod message Claude Code's AskUserQuestion tool caps every question at 4 options. My menu had 5. First strike: the end-of-run menu. Second strike: a blocker-recovery menu. Third strike: the same recovery menu two weeks later, after I thought I'd fixed it. That repetition is the story. Why this one keeps coming back A one-off validation error is not worth a blog post. What makes this one worth writing up is why it recurred: the cause wasn't a typo. It was a template. Suhail , my Claude Code orchestrator, is a set of markdown prompt files, and its menus live in those files as literal option lists: the template says exactly what to present, and the model presents it verbatim. Five options go into one AskUserQuestion call, the schema rejects it, and the round-trip to the model is wasted. In my runs the model then retried with four options and continued, which is why, the first two times, I let the retry count as the fix. The recovery is so cheap that the bug reads as a hiccup, not a defect. But decision menus are the natural accumulation point of any orchestrator. Every new capability wants a slot: continue, commit, skip, retry, abort, show status. The menu only grows. A 5-option template doesn't fail once; it fails on every run that reaches it, one wasted turn each time, until you fix the template. The failure mode worse than the error The wasted turn is the benign version. Suhail's public changelog records the malignant one: the interactive complete-handler menu grew past the cap, and instead of erroring, the presented menu simply lost its last option. The option that got pushed out of reach was Abort . Abort o

Models are improving quickly, but the cheaper options are often good enough.

There's a whole ecosystem of "agent skills" now — reusable instruction files you drop into Claude Code (or Cursor, or Copilot) to make the model write cleaner code, debug more carefully, use fewer tokens, and so on. Some of these repos have tens of thousands of GitHub stars. Almost none of them ship a single number telling you whether the skill actually does anything. That bothered me, because "adding a plausible-sounding instruction" and "adding an instruction that works" look identical until you measure them. So I built a benchmark with one rule, committed before I ran anything: No skill gets merged unless it beats both a no-instruction baseline AND a placebo prompt on its pre-registered target metric, measured on hidden hold-out tests, with accuracy not allowed to drop. Skills that fail are published anyway, with their numbers. The placebo arm is the part almost nobody runs, and it turned out to be the most important one. Why a placebo Most "battle-tested" skill collections that measure anything at all compare skill-on vs skill-off. The problem: that comparison can't separate "this skill works" from "adding any confident-sounding text changes the model's behavior." LLMs are suggestible. If you want to claim your skill did something, you have to show it beats a same-length instruction that contains no actual mechanism — just vibes. So every result here is a three-way comparison — off / placebo / on — run K=5–8 times per task per arm, in isolated git workspaces, graded by hold-out acceptance tests the agent never sees, with every raw run log committed to the repo and the README regenerated from those logs in CI. 516 runs total, all on claude-opus-4-8 . Finding 1: the placebo often made code bigger My anti-over-engineering skill ( underkill , ~20 lines) cut source LOC by -23.8% vs baseline at identical accuracy (60/60 hold-out passes). Good. But the interesting column is the placebo: a same-length "write clean, minimal, professional code" instruction didn't reduce c

OhNine is a free menu bar app that tracks Claude session and weekly usage limits in real time It sends native alerts at 80%, 91%, and 100% so a session never ends without warning The hard problem was never reading a number, it was making the warning arrive before the cutoff instead of after Building a zero telemetry tool changed how I judge every product I ship after it The Problem: Hitting a Wall You Cannot See For months, my Claude sessions ended the same frustrating way. I would be deep in a conversation, mid thought, actually making progress, and then the reply would just stop. No countdown. No yellow light. No warning that said "you have three messages left, wrap up." One second I was working, the next I was staring at a message telling me to wait for a reset I never saw coming. The frustrating part was not the limit itself. Usage limits exist for a reason, and I understand why they are there. The frustrating part was the total lack of visibility into where I stood. Claude Code and claude.ai will occasionally mention you are close to a cap, sometimes at 97 percent, which is technically a warning and practically useless, because by then you are already mid-thought with no time left to land it cleanly. It got worse once I noticed the layers. There is not one limit to track, there are several stacked on top of each other: a session limit, a rolling weekly cap, and separate caps depending on which model you are running. Switching models mid-session, thinking you had found a workaround, only to hit a wall from a different direction, was its own specific kind of frustrating. None of these layers showed up anywhere. There was no dashboard, no menu bar icon, nothing you could glance at the way you glance at your laptop's battery percentage before deciding whether to plug in. So the wall kept arriving the same way: mid-flow, mid-sentence, with zero warning. Coding sessions got cut off between a question and its answer. Writing sessions lost momentum at the worst possibl

Claude's new voice model will let you reschedule your meeting or draft an email