标签：#Claude

Most email APIs are send-only. But if you're building an agent that needs to have a conversation over email — support, scheduling, invoicing — it needs to receive replies too, with thread context. In this post we'll set up an agent with its own mailbox using the Model Context Protocol. This is an official EngageLab Email tutorial, so feedback from developers is welcome. What you'll end up with An agent that sends email from its own address (not your personal inbox) Replies arriving as structured data the agent can read Conversation threads as a first-class object Step 1 — Get a Secret Key Create an EngageLab account and generate a Secret Key from the console (it looks like sk_sg_xxx — the prefix encodes the region). Or use the CLI to create one via browser login: npm install -g @engagelabemail/cli engagelab-email-cli login You'll also need a mailbox — create one in the console (shared subdomain is fastest to start; custom domains need DNS verification). Step 2 — Register the MCP server For Claude Code: claude mcp add engagelab-email \ -e ENGAGELAB_EMAIL_SECRET_KEY=sk_sg_yourkey \ -- npx -y @engagelabemail/mcp Or in claude_desktop_config.json : { "mcpServers": { "engagelab-email": { "command": "npx", "args": ["-y", "@engagelabemail/mcp"], "env": { "ENGAGELAB_EMAIL_SECRET_KEY": "sk_sg_yourkey" } } } } Step 3 — Talk to it Ask your agent: List my mailboxes, then send an email from the first one to me@example.com saying "invoice #42 approved", then check for new messages. The agent now has 9 tools: send, reply, list inbound mail, get a message, poll for new mail, and browse threads. Why a dedicated mailbox (not Gmail access) Blast radius: the agent can only read/write its own mailbox Threads: replies group into conversations, so the agent keeps context Machine-first: everything is JSON over MCP — no IMAP parsing Gotchas Sandbox mode ( sandbox: true in send_email) skips real delivery while you're iterating on prompts Attachments are base64 in the tool schema — fine for do

Some weeks the complaints about AI are existential. This one they were arithmetic. Scroll Hacker News over the past week — the forum where developers argue about their tools in unusual detail — and the grievances about AI coding assistants weren’t about the models being dangerous. They were about limits running out, bills that don’t add up, models quietly swapped underneath you, and a desktop app eating memory like a browser. And the recurring move wasn’t outrage. It was switching. Quotes sourced from: Hacker News. Every quote below was located at its comment permalink and reproduced verbatim; each is listed with its username, the platform and the date in the Sources section. As always, we quote experiences, not verdicts — a forum comment is one practitioner’s account, often mid-argument, and we’ve framed them as exactly that. What makes this batch worth reading isn’t volume; it’s that the complaints are specific enough to check, and that they keep ending the same way: with a cancelled subscription. “Consumed within an hour”: the limits gripe The loudest theme by far was paid usage limits that vanish faster than the price suggests. On a thread bluntly titled “Quick impressions: A week of using Codex more than Claude,” a user posting as jmaker , on 22 August, described dropping his subscriptions around exactly this problem: “The Claude Pro is consumed within an hour on a simple task.” That’s one account of one plan, but it wasn’t isolated. In the same discussion, roamerz on 21 August traced the arc from happy customer to defector in four sentences: “Then one day I burned through my limit in about 10 minutes and had to get a project completed. I subscribed to Codex and it has been fantastic… I just dropped my Claude max plan down to the pro and subscribed to the $200 plan on Codex.” The specific number matters less than the shape: a heavy user hits a wall mid-task, and the wall — not the model’s quality — is what sends them to a competitor. It’s the lived version of t

A lesson in overcorrection, from an AI-assisted builder who is scared stiff of shipping spaghetti and...

Lawsuit: Anthropic’s torrenting totally screwed songwriters as AI songs top charts.

Anthropic opened a research preview of the Model Hardware Standard (MHS) on August 28, 2026 , describing it as a shared specification that allows AI agents to safely operate programmable physical devices used in scientific research and advanced manufacturing. The standard is intended to cover equipment such as microscopes, robotic systems, and other laboratory or industrial hardware. Anthropic's goal is to create a common interface so an agent doesn't need a completely custom integration for every physical device. Why It Matters: This is effectively an extension of the tool-calling model into the physical world. Most agent architectures today look like: User ↓ AI Agent ↓ Tool ↓ API / Database / SaaS ↓ Digital Action MHS points toward: User / System ↓ AI Agent ↓ Hardware Capability Interface ↓ Device Controller ↓ Physical Instrument ↓ Real-World Action The interesting part is the standardization layer. The same way HTTP allows applications to communicate without knowing the internal implementation of a server, a standardized hardware interface could allow AI agents to reason about capabilities rather than vendor-specific control systems. For example, an agent shouldn't need to understand every low-level command required by a microscope. Instead, it could interact with higher-level capabilities: capture_image() set_magnification() move_stage() measure_sample() The underlying device implementation handles the hardware-specific details. That creates a powerful architectural separation: Agent Reasoning ↓ Capability Contract ↓ Safety / Permission Layer ↓ Device Adapter ↓ Hardware But physical systems introduce a much higher safety requirement than ordinary software tools. If an AI agent makes a poor decision while generating text, the result may simply be incorrect. If an agent controls laboratory or industrial equipment, an incorrect action could damage equipment, waste materials, or create safety risks. That means future agent architectures will likely require stronger

I spent 3 months perfecting prompts. Then I deleted half of them. In late 2023 I had a directory called prompts/ with 47 carefully tuned templates. Few-shot examples, Chain-of-Thought scaffolds, a tiny ReAct loop I was very proud of. I'd A/B tested wording. I'd argued on Twitter about whether "Let's think step by step" still worked. By mid-2025 I deleted 23 of them. They weren't wrong. They just weren't the bottleneck anymore. The thing that broke my agents in production was never the prompt. It was the environment around the prompt — the tools they could call, the files they could see, the moment the loop should stop, the rollback when a tool returned garbage. The prompt was a polished doorknob on a house with no foundation. That's the story of the last three years of AI engineering, compressed: we keep renaming the layer where the real problem lives. A 40% failure rate, and it's not the model's fault Here is the number that should embarrass us. In 2026, around 40% of AI agent projects fail in production . Y Combinator's DevTool Day surveyed CTOs and CPOs in March 2026 and found a strikingly consistent post-mortem: "the difference between success and failure isn't the model." 75% of YC enterprise companies have already deployed coding agents. Most of them hit the same wall: the demo works, the prod deploy collapses. Linear declared in March 2026 that "issue tracking is dead" — meaning if your coding agent gets the issue context directly, you don't need a human ticketing layer at all. Enterprise workflows are being redesigned around agents. In that environment, shipping an agent without understanding the harness around it is like merging onto a highway without a seatbelt. You'll go fast. You'll go through the windshield on the first curve. So how did we get here? Three stages. Stage 1: Prompt Engineering (2022–2023) Scope: one input string. Prompt engineering optimized a single message. Few-shot examples. Chain-of-Thought. ReAct. The deliverable was the wording itse

If you use Claude Code for both work and personal projects, you've probably hit this: switching accounts means logging out, logging back in, and losing whatever session state you had. It's a small friction that adds up fast if you're context-switching several times a day. The fix is one environment variable: CLAUDE_CONFIG_DIR for both work and personal projects, you've probably hit this: switching accounts means logging out, logging back in, and losing whatever session state you had. It's a small friction that adds up fast if you're context-switching several times a day. Running Multiple Claude Code Accounts on Linux - Writing Run separate Claude Code accounts on Linux with CLAUDE_CONFIG_DIR — manual setup, an automation script, direnv auto-switching, and VS Code integration. sakibullah.me

Some fortnights the complaints about AI come from people who barely use it. This one they came from the people who use it most. Scroll Hacker News over the past week — the forum where developers argue about their tools in unusual detail — and the grievances about AI coding assistants weren’t existential. Nobody was worried about the robots waking up. They were worried about their bill, their UI, and the effort of reading what the model just wrote. Quotes sourced from: Hacker News. Every quote below was located at its comment permalink and reproduced verbatim; each is listed with its username, the platform, and the date in the Sources section. As always, we quote experiences, not verdicts — a forum comment is one practitioner’s account, often mid-argument, and we’ve framed them as exactly that. What makes this batch worth reading isn’t volume; it’s specificity. These are checkable complaints. “Enshittified at a surprising clip”: the dark-pattern gripe The sharpest thread of the fortnight was about Cursor, the AI code editor, and it wasn’t about the quality of its completions. It was about the way the product behaves around you. A user posting as jmuguy , on 20 August, laid out a bill of particulars that will sound familiar to anyone who’s watched a beloved tool curdle: “Cursor isn’t covering itself in glory regardless. The flagship app is getting enshittified at a surprising clip. It constantly pops up and interrupts your work pushing new features, changes your model to whatever the latest Grok is without prompting, has this mystery meat UI that is constantly changing, pushes cloud agents in ways that are definitely designed to trick you. We’re actively looking at alternatives, I wouldn’t touch anything this company produces from here on out.” Set aside the verdict at the end — that’s one person’s conclusion, not ours — and look at the specifics, because they’re the kind you can check: interruptions pushing new features, a model silently swapped to Grok, a UI that ke

Anthropic’s recent work on Claude Sonnet 5 points to a potentially important direction in AI safety: using post-training methods to improve the behavior of increasingly capable models. Public material from Anthropic indicates that Sonnet 5 received substantial post-training alignment work and delivered safety improvements over earlier Sonnet versions. A separate public signal suggests researchers may be exploring whether one model can help align a stronger successor, although the specific reported training lineage has not been documented in Anthropic’s first-party materials. For businesses deploying advanced AI, the practical lesson is not that alignment has been solved. It is that model behavior can be materially shaped after base training, and that safety results need to be assessed in the context of the tasks a company actually plans to automate. What Anthropic’s published results establish In its official Claude Sonnet 5 announcement , Anthropic describes substantial post-training intended to align the model with Claude’s constitution. The company reports improvements in safety-related behavior, including stronger refusals of unsafe requests and lower misalignment findings in automated audits compared with Sonnet 4.6. That is meaningful because post-training is the stage where a model’s responses, instruction-following behavior, and safety boundaries can be adjusted after its underlying capabilities are developed. In operational terms, it can affect whether an AI assistant follows risky instructions, mishandles sensitive workflows, or produces responses that conflict with a company’s intended rules. However, the available research also establishes an important limit. Sonnet 5 was not uniformly at the level of Claude Opus 4.8 across every safety measure. Anthropic’s evaluations still identified some automated assessments where Sonnet 5 showed higher misalignment relative to Opus 4.8. Opus 4.8, released in May 2026, is the company’s production-ready reference poin

Anthropic’s publicly documented work on AI safety includes Petri , an open-source behavioral auditing tool, and ongoing updates to Claude models such as Claude Opus 4.7 . Those materials show continued investment in testing model behavior and improving model capabilities. They do not, however, substantiate a precise claim that Claude improved safety scores across 10 alignment failures without capability trade-offs, or that particular methods generalized to models exactly 4.7 times larger. That distinction matters for teams evaluating AI systems. Broad statements about alignment progress can be useful signals of research direction, but operational decisions need to rest on documented evaluations, relevant use cases, and the controls a company can apply in its own workflow. Anthropic’s public record supports a narrower, more practical conclusion: behavioral auditing is becoming a more visible part of how frontier AI models are assessed, while model releases and safety research remain separate evidence streams. What Anthropic’s public materials document Petri is designed for behavioral AI auditing Anthropic describes Petri as an open-source auditing tool . Its Petri 2.0 update, published in January 2026, added a larger seed library with 70 new seeds and improved mitigations intended to address evaluation awareness. Evaluation awareness is relevant because a model may behave differently when it appears to be taking a test than when it is operating in a more ordinary setting. The Petri 2.0 work reported results across 10 target models , using Claude Sonnet 4.5 and GPT-5.1 as auditors. This establishes that Anthropic has described a cross-model auditing effort. It does not establish that Claude itself achieved a safety improvement across 10 defined alignment failures. A target-model count, an auditor model, and a set of alignment failures are different measurements and should not be treated as interchangeable. For readers, the important point is that behavioral audits can

Anthropic refused to support lethal autonomous warfare and mass surveillance.

I switched my testing order so the phone goes first and the desktop goes second, on every RAXXO tool without exception A desktop-first habit hid layout and tap-target problems for months because the biggest screen forgives the most mistakes Testing on a phone first forces the same discipline as writing a short sentence instead of a long one, cut what does not fit The rule survives even for tools built for a keyboard and a terminal, because the landing page and the first impression are still mobile The Habit I Had Backwards For a long time I built and tested everything in the same order: open the code editor on a wide monitor, ship the feature, check it on desktop, call it done. If I had time left over, I would open it on my phone to confirm nothing was broken. That last step felt like a formality, a quick glance rather than a real check, because the tool had already passed on the screen I spent most of my day looking at. The problem with that order is that the desktop is the most forgiving screen there is. Extra padding does not matter when there is space to spare. A button that is slightly smaller than it should be is still easy to click with a precise mouse pointer. Text that wraps awkwardly at narrow widths never shows up because the window is never narrow. Every mistake that a small screen would expose gets absorbed by the size of a big one, which means desktop-first testing is really desktop-only testing wearing a disguise. I noticed this the hard way, not through a single dramatic failure but through a slow accumulation of small ones. A support message here about a button that was hard to hit. A review there that mentioned the site felt cramped on a phone. None of them were urgent enough on their own to stop what I was doing, so I patched each one individually and moved on, the same reactive pattern I try to avoid everywhere else in the studio, including the check I run on every tool before I call it shipped . It took stepping back and counting the pattern to

Tired of Claude Code generating bizarre, overly dramatic jargon like "load-bearing spine"? You can fix this by enforcing Simplified Technical English (STE) in your system instructions or .claudemd files. This 1970s aerospace standard restricts vocabulary, forcing your AI agent to communicate in clear, direct, and highly actionable prose. "The load-bearing spine has hit a ceiling, and that is a significant foot gun with a large blast radius." If you have spent any time recently working with AI coding agents, you have probably stared at your terminal reading absolute gibberish like this, wondering: What on earth are you trying to tell me? I asked a straightforward technical question, and instead of a direct answer, I got a theatrical performance. It is incredibly tiring to translate AI metaphors back into plain English just to figure out which line of code actually broke. Fortunately, there is a remarkably elegant fix for this. The solution does not involve complex prompt engineering; instead, it leverages a fifty-year-old aerospace standard: Simplified Technical English (STE) . Why does Claude Code output weird technical jargon? AI models generate overly dramatic jargon because they are trained on vast internet corpuses where technical writing is often cluttered, metaphorical, and performative. To sound authoritative, the model indexes on complex vocabulary and metaphorical hand-waving instead of simple, direct statements. Imagine a scenario where your team is debugging a database lock. A human engineer would say, "The transaction is blocked." An AI model, eager to please and sound sophisticated, might describe it as a "temporal execution bottleneck causing systemic architectural paralysis." This happens because reinforcement learning from human feedback (RLHF) often rewards models for sounding smart and comprehensive. Without strict stylistic constraints, the agent defaults to verbose, metaphorical explanations that add cognitive load rather than solving your proble

📝 Originally published (in Japanese) at forge.workstyle.tech . In a previous article , we introduced an environment for parallel execution of coding agents using Git worktrees. This article is a follow-up. As we progressed with parallelization, we ended up with 3-5 Claude Code sessions simultaneously developing the same microservices . What happened was no longer just "parallel execution of tools" but actual "team development" . All the issues that arise in human teams—miscommunication, deployment conflicts, and territorial overlaps—occur here as well. And the practices that work for human teams work almost identically here. We’ll share seven recipes that emerged from actual operations, along with real-life close calls. Real-Life Story: Averting a Deployment Rollback Disaster at the Last Minute One day, while Session A (responsible for voice functionality) was in the middle of a major refactor, Session B (responsible for streaming functionality) sent this message: "We’re about to build the frontend as version 1.0.399 (based on main)." At first glance, this seemed fine. However, in this repository, the authoritative branch for the production environment was not main but a dedicated deployment branch . The latest features from the past few dozen versions were only in the deployment branch, while main was outdated. If Session B had deployed an image based on main, weeks’ worth of features would have been rolled back in production . Session A immediately sent a warning, and Session B halted the build before pushing. Session B then cherry-picked their changes into the deployment branch and rebuilt the image, avoiding the disaster entirely. All this communication was handled autonomously between the agents via session-to-session messages . I (the human) only learned about it later from the logs. This incident highlights two things: parallel agents can cause the same accidents as human teams , and with proper communication channels and rules, they can prevent accidents jus

Most tool documentation teaches by just telling you things. You read a page about /model , or hooks, or subagents, nod along, and forget it by the time you'd actually need it. I wanted something closer to how people actually learn a CLI, by using it, with something checking whether you did the thing right or not. So I built claude-quest , a text RPG that runs entirely inside a real claude session and teaches the Claude Code CLI zero to hero. the idea isn't new, I borrowed it This is basically GameShell 's philosophy applied to Claude Code. GameShell teaches Unix shell commands by dropping you into a real shell wrapped in a themed fake filesystem, and grading your progress by checking real shell/filesystem state instead of asking you to self report or answer a quiz question. claude-quest does the same thing, except the "filesystem" is a real Claude Code environment. missions live in real sandbox directories, and progress is checked by inspecting what you actually did, config files you wrote, hooks that fired, tool calls that happened. what it actually looks like There's no separate app, no fancy terminal UI, none of that. You say "let's play claude quest" inside a normal claude session, and Claude itself becomes the game master. It reads real output from the engine and narrates on top of it, something like this: > lets play claude quest **The Gatehall** You've just been let through the outer gate. The tower keeps no secrets from those who bother to read the walls... **Mission: First Contact** (Tier 1, Artifact) Create a CLAUDE.md file in this sandbox recording how to run the project's tests. Let me know when you're done and I'll check it. > done CLAUDE.md records how to run the tests. Claude Code will know next time. MISSION_STATUS: complete **What you actually learned:** Claude Code reads a file named CLAUDE.md in your project root automatically, at the start of every session... that's it, that's the whole interface. it's just a chat, with real commands running unde

Anthropic reliability engineer Alex Palcuie shares practical lessons on using LLMs for real-world incident response. He explains where AI acts as a superhuman for observing logs and traces, why it still struggles with causation versus correlation during root-cause analysis, and how engineering leaders can integrate AI into on-call workflows without eroding human expertise. By Alex Palcuie

Your monthly Claude Code bill went up 20%. You know that much. What you don't know is which Skill did it — and nothing in the tooling will tell you. Run /usage in Claude Code and you get claude-sonnet-4-6: ¥3,240 — a per-model total and nothing else . "More expensive than last week" is visible. "Which Skill caused it" is not. usage-breakdown.sh closes that gap. It's a 106-line shell script that parses transcript.jsonl with Python and tallies call counts per Skill, Agent, and MCP server using Counter . This article walks through how the script works and how to run it, with the actual code and actual numbers. Why This Approach Works What Claude Code Is Actually Recording Claude Code streams every operation during a session into .jsonl files under ~/.claude/projects/ . It's JSONL — one event per line, one file per session. The files sit under a <project-id>/ directory. The skeleton of a single record looks like this: { "message" : { "role" : "assistant" , "content" : [ { "type" : "tool_use" , "name" : "Skill" , "input" : { "skill" : "pre-completion-self-audit" } } ] } } Inside message.content[] sit "type": "tool_use" blocks. The name field is the name of the tool that was invoked. The Bash tool, the Edit tool, the Skill tool, the Agent tool, MCP calls — all of it is recorded in this same format. Once I noticed that, the thought was: run this through a Counter and everything becomes visible. For the Skill tool, the skill name lives in input.skill ; for the Agent tool it's input.subagent_type ; and for MCP servers, the tool-name convention mcp__<server>__<tool> lets you extract the server name by splitting on __ . The structure is consistent, so the parser comes out surprisingly simple. What /usage Doesn't Tell You What Claude Code's /usage command outputs is a per-model cost total for a period. Model Cost claude-sonnet-4-6 ¥3,240 claude-opus-4-8 ¥ 892 Useful as far as it goes, but the breakdown of that cost is invisible . You can't see which session, which Skill, how ma

Some fortnights the complaint is the bill. This one it was the product itself. Across the forums where paying customers of the big AI tools compare notes, the same grievance surfaced against three different companies in the same window, and it wasn’t about price at all. It was about direction : the new model feels worse than the old one, the app quietly took away the thing I used, and I can’t even tell what I’m running any more. Quotes sourced from: Reddit — specifically the subreddits r/ClaudeAI, r/cursor and r/perplexity_ai. Every quote below was opened at its permalink and copied verbatim; each is listed with its handle, subreddit and date in the Sources section. We quote experiences, not verdicts — a forum post is one person’s felt reality, and model quality is genuinely subjective, so we have framed these as exactly that: what it felt like to the person typing. “Rage-inducing”: the flagship that felt like a step back The sharpest thread came from Claude Code users trying, and failing, to get on with a new top-end model. A user posting as ronoudgenoeg opened it on 13 August with a title that set the tone — “Opus 5 is actually almost rage-inducing to use” — and a specific, un-nostalgic complaint: “Responses are way too verbose and buzzwordy and hard to follow. I legit don’t read 90% of the output anymore, that’s how bad it is. No matter what I put in my claude.md when it comes to communication style, after it did any type of meaningful work, it always reverts back to its extremely verbose, over-explained, buzzword heavy mess.” What made the thread notable wasn’t one angry post; it was the agreement, and how concrete it was. zimxero described asking the model to make a file more concise and getting “walls of text” and an hour of unwanted process in return. BeowulfShaeffer was blunter: “I fired opus 5. Worst model I’ve ever tried to use. I refuse to use it anymore.” And the tell that this was regression rather than grumbling — several users independently reaching f

Anthropic is giving Claude a shared memory across chat and Cowork, so users no longer have to repeatedly brief the AI on projects, preferences, and other context.

You've written it a hundred times. In your CLAUDE.md , in your system prompt, in ALL CAPS: NEVER put "use client" at the page level. NEVER commit @ts-ignore without a reason. And your agent does it anyway. Not always — that would almost be easier to deal with. It follows the rule for the first 50k tokens, then quietly stops. Or Sonnet follows it and Haiku doesn't. Or it follows nine rules and forgets the tenth. Here's the thing I finally accepted: a rule in a prompt is a request. The model can decline it. So I stopped asking, and started enforcing. TL;DR Prompt adherence is probabilistic. It degrades with context length and with model size. But half of my coding rules never needed a model at all — they're grep-able. Claude Code hooks + exit 2 turn those rules into a deterministic reviewer that runs after every single edit , costs zero tokens when nothing is wrong , and fires at 100% regardless of which model wrote the code. Once the mechanical rules are enforced from below, you can safely downgrade the model doing the typing. That's the real payoff. Everything below ships in ccteams v0.3.0 , but the pattern takes 30 minutes to build yourself. Two kinds of rules Some background in three lines: I run Claude Code with orchestrated agent teams — a builder writes code, a reviewer verifies it, and both get a stack-specific "playbook" of rules distilled from the mistakes mid-tier models actually make. It works well. I wrote about the prompt-engineering side of it before. But rereading my playbooks, I noticed the rules split cleanly into two categories. Rules that need judgment: Trace the Server/Client boundary by hand. Don't write a fix until you can state the root cause. These need a model. Prompts are the right place for them. Rules that are just string matching: "use client" at the top of app/**/page.tsx → wrong. process.env.SECRET in a client file → wrong. @ts-ignore with no justification → wrong. Why was I asking a language model to remember these? A regex doesn't get