The Weekly Build

Here's a problem you'll recognise even if you've never touched a line of code. You've got an MCP server sat there, connected and working, and you want the model to actually use it well instead of poking at it randomly. Most people just describe the tool in a sentence and hope. That's not enough.

This week alone brought a fresh reminder of why. There's an established MCP server, blender-mcp, sitting at 26,688 stars, that lets any LLM drive Blender's 3D tools directly, and there's one doing the same for Adobe Premiere Pro, and another wiring Claude straight into Excel, Power Query, DAX, VBA, PivotTables, the lot. Powerful tools. Forty parameters each, easily. Point a model at something that size with no plan and watch what happens.

The failure mode is always the same. You give Claude access to a tool with forty parameters and it either freezes and asks twenty questions, or charges in and calls the wrong function with half the arguments missing. Neither is the tool's fault. It's a briefing problem.

The prompt below fixes that by making the model plan before it touches anything. You give it the tool's shape, the outcome you want, and an instruction to lay out its approach first, and that's the whole trick. Separate the thinking from the doing. Make the thinking visible so you can catch a bad plan before it becomes five bad tool calls.

Why does this work? Frontier models reason far better about a plan written out in plain English than they do while silently reasoning and executing at the same time, and asking for the plan first forces a commitment to one approach, giving you a moment to say "no, not like that" before anything happens for real. A good contractor sends you a quote before picking up a tool, not after.

Adapting it is mostly about the middle section. Swap the tool description for whatever server you're running. Excel, Blender, Premiere. Swap the outcome for your actual task, but keep the plan-then-execute structure. That part doesn't change, whatever you're pointing it at.

Here's the prompt. It makes the model state its plan and wait for your go-ahead before it calls anything.

You have access to a tool called [TOOL NAME], which can [WHAT THE TOOL DOES, e.g. "read and write cells, run Power Query refreshes and build PivotTables in an Excel workbook"].

My goal: [WHAT YOU ACTUALLY WANT TO END UP WITH, e.g. "a PivotTable summarising monthly revenue by region from the raw data in Sheet1"].

Before you call the tool, do this:
1. State in plain English the exact steps you plan to take, in order.
2. List which tool functions each step will use.
3. Flag anything ambiguous about my request and ask me before proceeding, rather than guessing.

Wait for me to confirm the plan. Only then execute it, one step at a time, telling me what happened after each step.

This Week's Challenge

Pick any MCP server you've already got running, Excel, Blender, whatever's on your machine. Open a fresh Claude chat, paste the prompt above with the tool and goal filled in, and read the plan before you approve anything.

You'll end up with one of two things: a plan you're happy to greenlight, or a clear reason not to run it at all. Both beat watching the model improvise and finding out afterwards what it actually did.

Apologies for the late post, I am currently travelling around Japan with the family! Appreciate you all and I hope you’re having a great week.

Forward this to one person who should be using AI better than they are. Reply with what you built, tried or broke this week. I read every one.

Gareth, founder of The Anthropic Stack (theanthropicstack.com)

SpaceX bought Cursor. That sentence alone should have made every developer using it sit up. What followed matters more. OpenAI announced it is winding down the contract that let Cursor route requests through OpenAI's models. Not a slow fade, a decision, published, dated. If you build inside Cursor and lean on GPT-class models to do it, the ground just moved under you.

Here's the part people are missing. Cursor built a genuinely good editor, and millions of developers now run production work through it daily. But the model layer was always rented, not owned. Rented things get repossessed when the landlord changes, and that's really the whole story here, whatever gets said about Cursor specifically.

SpaceX runs SpaceX. Whatever Cursor becomes under that ownership, it will serve SpaceX's interests first. OpenAI clearly decided it didn't want its models powering a competitor's internal tooling, however that competitor happens to package it. Reasonable call from OpenAI's side. Much worse one from the side of anyone who built a workflow assuming the pipes would stay connected.

The lesson isn't "don't use Cursor." Cursor still works today. The lesson is that your AI coding stack has a supply chain, same as any other piece of infrastructure, and supply chains get cut when the ownership above them changes hands. Anthropic ships Claude direct. OpenAI ships GPT direct. The tools sitting between you and the model are a layer you don't control. This week is proof that layer can vanish overnight.

If you're deep in Cursor right now, check what model access you actually have locked in. Do it this week, rather than when something breaks mid sprint.

The Stack This Week

Anthropic's Python SDK Fixes the Bedrock Bug That Was Quietly Breaking Requests anthropic-sdk-python v1.2.0 (GitHub) landed with updates to the beta files and skills namespaces, plus a fix for AWS Bedrock request signing. Sounds small. It wasn't, for anyone routing Claude through Bedrock rather than direct. Request signing is the handshake that proves your call is legitimate, and when it's broken you get failures that look random and take hours to trace back to the SDK rather than your own code. If you're on Bedrock, update now rather than debugging a ghost next week.

Claude Code Adds Feedback Drafting and Spinner Tips for Teams Version 2.1.247 of Claude Code (GitHub) brings a new SendFeedback tool and customisable spinner tips for organisations. Small release, incremental features, nothing that changes how you work today. Worth knowing about anyway. Anthropic ships Claude Code updates fast enough that it's easy to fall a few versions behind without noticing, and organisational customisation is the kind of thing your admin will want turned on before your whole team asks for it separately.

A Security Report Found 227 Bad Install Commands Pointing at Claude, Codex and Hermes Ars Technica's report on unowned code in corporate networks (Ars Technica) found 227 install commands sitting in corporate documentation that point to repositories nobody owns. Claude, Codex and Hermes all got caught up in it. The mechanism is simple, and that's what makes it dangerous. An AI tool suggests an install command, the command references a package name that sounds plausible, and if nobody's claimed that name yet, an attacker can. Check your dependency lockfiles against actual maintained packages this week, not after something breaks.

Would a supply cut like Cursor's change how you choose your coding tools? Tell me in the comments.

Forward this to one person who should be using AI better than they are. Reply with what you built, tried or broke this week. I read every one.

Gareth, founder of The Anthropic Stack (theanthropicstack.com)

The Shiplog

• Leonxlnx/taste-skill (GitHub) - Sitting at 81,471 stars, this is a skill built to stop Claude producing the generic, safe, slightly beige output that frontier models default to when nobody pushes back. It's written in JavaScript and slots into the claude-code ecosystem rather than replacing anything. The idea is sound. Models optimise for inoffensive by default, so a skill that argues for a stronger opinion in the output is solving a real problem. Whether it actually changes the writing or just changes the vibe of the prompt is something you'll have to judge on your own content. Taste resists a star count as proof.

• ComposioHQ/awesome-claude-skills (GitHub) - A curated list, 73,575 stars deep, of Claude Skills and the tools built around them. Awesome-lists live or die on curation quality rather than size. This one has grown fast enough that quality is now the open question. It's a genuinely useful starting point if you're building your first skill and don't know what's already out there, so treat it as a map rather than an endorsement. Being listed isn't the same as being good.

• K-Dense-AI/scientific-agent-skills (GitHub) - 163 pre-built skills, over 100 scientific databases, 35,249 stars and a claimed 175,000 scientists using it, according to the project itself. This is what a domain-specific skills library looks like when someone commits properly rather than bolting on three prompts and calling it a product. It works with Claude Code and other agent frameworks, so the integration cost for a lab already running Claude is low. If you're outside science, this one isn't for you, and that specificity is exactly why it works for the people it's built for.

• tt-a1i/archify (GitHub) - An agent skill for generating architecture, workflow, sequence and data-flow diagrams as self-contained HTML files, complete with motion and export. 22,820 stars. Most diagram tools ask you to learn a syntax first and draw second. Archify flips that. It asks the agent to draw the diagram from the code or the conversation, which is the right way round if you actually want documentation to stay current instead of rotting in a wiki nobody opens.

• anthropics/anthropic-sdk-typescript (GitHub Releases) - The official TypeScript SDK moved to v0.122.0 this week. The useful bit: the beta files and skills namespaces have graduated to general availability shapes, with dated beta header pins removed. Two smaller releases landed alongside it. The Bedrock SDK went to v0.33.3 and the AWS SDK to v0.6.6, both fixing the same bug: environment credentials weren't being prioritised over AWS_PROFILE. Running Claude through Bedrock? That's the kind of quiet fix that costs you a bad morning if you miss it.

The Take

Four of this week's five biggest developer repos are skill libraries. Not agents, not frameworks, not new models. Libraries of instructions that tell an existing model how to behave in a specific domain.

That's a tell about where the actual advantage has moved. Nobody's racing to build a better base model in their spare time, because they can't. What they can do is write down, precisely, what good scientific reasoning or good architecture documentation or good taste actually looks like, and hand that to a model that already reasons well.

The failure mode is obvious once you see it. A skill is only as good as the judgement encoded inside it. A library with 175,000 claimed users and one with none can look identical in a README. Star count tells you attention, not correctness. Read the actual skill file before you install someone else's opinion of good taste or good science into your agent. That's where the real content lives.

Which skill libraries have you actually checked line by line before installing, and which did you just trust the star count on?

Tell me in the comments.

Forward this to one person who should be using AI better than they are. Reply with what you built, tried or broke this week. I read every one.

Gareth, founder of The Anthropic Stack (theanthropicstack.com)

P.S. Shipping something this week? Railway gives Anthropic Stack readers $20 in credits to start: theanthropicstack.com/railway. It is a referral link, so I earn a small cut if you stay. I only point you at tools I run myself.

The Weekly Build

CLAUDE.md files are having a moment, and there's a good reason for it.

A CLAUDE.md is just a text file that sits in your project and tells Claude Code how you want it to behave. What to check before it writes anything, what mistakes to avoid, how to talk to you. No plugin, no install, just instructions Claude reads every time it starts working.

The one trending right now has 205,537 stars and is built from Andrej Karpathy's public notes on where large language models tend to go wrong when they write code. You don't need to understand the underlying mistakes to benefit from the fix. You just need the file in the right place.

Here's how to get one running in under thirty minutes, even if you've never touched a terminal before.

Install Claude Code if you haven't already, Anthropic's own install guide covers it in about two minutes. Open a terminal and navigate to the folder you want Claude working in. `cd path/to/your/project` does it. Go to `multica-ai/andrej-karpathy-skills` on GitHub, open the CLAUDE.md file and copy the whole thing.

In your project folder, create a new file called exactly `CLAUDE.md` and paste the contents in. Start Claude Code in that folder and ask it to summarise the file back to you in plain English, so you know what you've just installed.

Now run a task you'd normally give it, something you've asked before so you've got a fair comparison. Watch what it does differently. Does it check its own work before saying it's done? Does it ask before assuming?

Keep the file if it helps you and delete the lines that don't fit how you work. It's yours now, not Karpathy's.

This costs nothing and breaks nothing. Worst case, you delete the file and you're back where you started. Best case, you've got a Claude Code setup that stops guessing and starts checking, and a file you can hand to anyone else on your team so they get the same behaviour without a training session.

Here's the prompt to run once the file's in place, so you can see the difference for yourself rather than taking my word for it.

I've just added a CLAUDE.md file to this project with instructions for how you should work. Before starting any task, read that file fully and confirm back to me in plain English what behaviours it changes. Then take on this task: [DESCRIBE A REAL TASK YOU WANT DONE IN THIS PROJECT]. As you work, narrate any point where the CLAUDE.md file changes what you would otherwise have done, so I can see the difference it's making. Finish with a short list of what you checked before calling the task complete.

This Week's Challenge

Open Claude Code in any project folder you already have. Ask it to read the CLAUDE.md file from `multica-ai/andrej-karpathy-skills` on GitHub and tell you which three rules would have changed something it did for you last week.

Fifteen minutes is the whole cost.

You'll know whether the file's worth keeping before you commit to it, which beats installing something on faith and finding out in a month it's fighting your own workflow.

Try it and tell me in the comments what happened. I read every one.

Forward this to one person who should be using AI better than they are. Reply with what you built, tried or broke this week. I read every one.

Gareth, founder of The Anthropic Stack (theanthropicstack.com)

Someone searching for how to install Claude Code found what looked like official documentation. It ranked well on Google. It sat on an Anthropic domain. It told them to run a curl command piped into bash, the way half of developer tooling gets installed these days. They ran it. It installed an infostealer on their Mac.

That's the story worth sitting with this week, more than any model release or roadmap update. Boring, in exactly the way that works.

The attacker didn't need to break Anthropic's security. They needed to publish a Claude artifact convincing enough to rank for "Claude Code install", and let Google do the rest. A user trusted the domain. They trusted the format. Install docs look like install docs, and nobody reads a curl command character by character before they run it. This happens whenever a platform lets anyone publish content under its own name and search engines can't tell official from impersonated.

Here's the part that should worry you if you install developer tools for a living. This trick works precisely because the install pattern itself is fragile. Curl into bash gives a script full control the moment you hit enter, with no sandbox, no review and no second chance to check what it actually does before it runs. We've normalised that as a convenience. It was always a risk. This week it stopped being theoretical for at least one person.

There's no clever fix here, and I'm not going to pretend there is one. Check the domain properly. Read the script before you pipe it anywhere. If an install command showed up from a search result rather than a link you already trusted, treat it as unverified until you've looked at what it does.

Anthropic will presumably clean this instance up. Another one will rank next month for a different tool, on a different platform, dressed as different documentation. The pattern is what matters, not the single artifact.

The Stack This Week

Claude Cowork Gets an Official Plugin Marketplace claude-plugins-community (GitHub) is Anthropic's own repository for extending Claude Cowork and Claude Code through community-submitted plugins. It sits at 746 stars with 190 added today, which tells you the timing of the push rather than anything about long-term adoption. The repo itself is a read-only mirror, and submissions go through a separate portal rather than pull requests. Watch this space if you're building tooling around Claude, to see what other developers are shipping into the ecosystem. Worth a look given the malicious artifact story above too: an official marketplace with a submission process is exactly the kind of trust signal attackers will eventually try to imitate.

MCP's New Roadmap Has Developers Arguing The MCP roadmap (Hacker News) picked up 209 points and 133 comments, a lot of noise for a protocol announcement. The source doesn't spell out the specific commitments, so treat any secondhand summary you see this week with caution until you've read it yourself. What the comment count tells you is that people building on MCP have opinions about where it's heading. The protocol has enough production usage now that direction changes actually matter to someone's roadmap. Read it in full rather than trusting a summary, this one included.

Nineteen Talks From Code w/ Claude, Free Anthropic uploaded the full run of Code w/ Claude SF (Reddit) to YouTube. Nineteen videos, over eight hours, featuring the creator of Claude Code alongside Vercel's CEO and Bun's creator. That's a genuinely useful pile of material if you build with these tools day to day, not marketing filler. Eight hours is a lot to get through in one sitting. Pick the sessions closest to what you're actually building and skip the keynote fluff.

Core MCP Servers Get a Routine Update Release 2026.8.18 of modelcontextprotocol/servers (GitHub) touched the everything, time, fetch and git server packages, the foundational servers most MCP setups end up depending on somewhere in the chain. Nothing flashy here. Update, check nothing broke in your setup, move on.

Have you ever nearly run a curl command you shouldn't have?

Tell me in the comments.

Forward this to one person who should be using AI better than they are. Reply with what you built, tried or broke this week. I read every one.

Gareth, founder of The Anthropic Stack (theanthropicstack.com)

The Shiplog

• siteboon/claudecodeui (GitHub) - 12,995 stars and climbing. The pitch is simple: run Claude Code, OpenCode, Cursor CLI and Codex from your phone or a browser tab instead of a terminal on your desk. Built in TypeScript, and it works across all four tools rather than locking you into one. If you've ever wanted to check on a long-running agent from the sofa, this is the reason to. The real question is how many of you actually want that much access to a coding agent from a phone.

• mcp-use/mcp-use (GitHub) - Over 10,000 stars for a fullstack framework that builds MCP apps for ChatGPT and Claude, plus MCP servers for agents to call. Most MCP tooling so far has been either a spec document or a single-purpose server. This is neither. mcp-use routes requests to MCP servers. It's plumbing for the whole pipeline, from server to client, and the star count says a lot of people needed exactly that. Worth your weekend if you've been bolting MCP servers together by hand.

• zhaoxuya520/reverse-skill (GitHub) - Reverse engineering and authorised penetration testing get their own skill router. It sits on top of Claude Code, Cursor and Cline, with 10,254 stars behind it. AI-powered routing decides which tool handles which step. There's a self-evolving knowledge base underneath. Security researchers get a proper argument for domain-specific tooling here, not a general assistant wearing a costume. I'd want that self-evolving claim documented before I trusted it with anything sensitive.

• github/copilot-sdk (GitHub) - GitHub has opened up a multi-platform SDK, written in Java, for embedding the Copilot Agent directly into your own apps and services. It's already past 10,000 stars. Not Claude, and not trying to be. GitHub is making a clear bet that Copilot's future sits inside other people's products rather than just inside the editor. Worth watching even if you build with Anthropic's stack every day.

• cursor/plugins (GitHub) - The official Cursor plugin specification. 3,964 stars, with 473 added in a single day. This is the scaffolding that decides what a Cursor extension is even allowed to do, and the spike in stars tells you people are already building against it. Early days for anyone wanting to extend Cursor properly. Read the spec before you build, not after.

The Take

Three of this week's five items are routing layers. mcp-use routes requests to MCP servers. reverse-skill routes between Claude Code, Cursor and Cline depending on the security task. Copilot's SDK routes an agent into whatever app you're building. Nobody set out to build "a router." Each team built the thing they actually needed, and it turned out to be a router.

That's what happens once you're running more than one model or more than one tool against the same problem. You stop asking which one is best. You start asking which one is right for this specific call. Same instinct behind matching model to task rather than defaulting to the frontier model for everything. The routing layer is what a multi-model workflow becomes once it's mature enough to admit no single tool wins every time.

Where do you draw the line between routing and just picking one tool and living with it?

Tell me in the comments.

Forward this to one person who should be using AI better than they are. Reply with what you built, tried or broke this week. I read every one.

Gareth, founder of The Anthropic Stack (theanthropicstack.com)

P.S. Shipping something this week? Railway gives Anthropic Stack readers $20 in credits to start: theanthropicstack.com/railway. It is a referral link, so I earn a small cut if you stay. I only point you at tools I run myself.

The Weekly Build

Here's a pattern I see constantly with SME owners: proposal writing.

Say you run a small consultancy or agency. A lead comes in, and you need a proposal out fast, before they cool off and ring a competitor. That's the whole game.

Here's the before. Someone senior blocks out two hours, opens the last proposal that sort of fits, strips out the old client's name, forgets one instance of it, and sends a document that still says "Hi Sarah" to a client called Dave.

Pricing gets copied from memory, or from a spreadsheet nobody's updated since March. Scope gets written from scratch every time, because nobody trusts the template enough to lean on it fully.

By the time it goes out, the lead is two days cold. The moment that made them ring you has passed.

Multiply that by ten proposals a month and you've lost most of a working week to a task that barely changes shape from one client to the next.

So separate the parts that change from the parts that don't.

Build once. Your standard scope language, your pricing logic, your terms, all set up the once. Then feed Claude the call notes or transcript and have it draft the client-specific sections against that skeleton. Names, scope, price, timeline, done. Give it a five minute human pass to sense-check the numbers and tone, then send it.

Proposal writing was never really a writing problem. It was a template problem wearing writing as a disguise, and once you see that, the fix stops feeling like a big lift.

Sell the outcome and this is easy to picture. A proposal turnaround that used to eat an afternoon becomes something you finish before the coffee goes cold.

Now the failure mode, because there's always one. Someone builds this, tests it twice, loves it, and six weeks later a junior team member is manually rewriting half the output because nobody explained why the skeleton exists or what not to touch.

If the person using it needs a training manual, the interface is wrong. Three minutes of Loom showing the actual workflow beats a page of instructions nobody reads. That's a rule I hold to across every automation North Roots builds, not just this one.

Configure per client. That's the whole discipline.

This prompt takes your call notes and standard scope skeleton and drafts the client-specific sections of a proposal in one pass.

You are helping me draft a client proposal. I will give you two things: my standard proposal skeleton and the notes or transcript from a client call. Your job is to produce the client-specific sections only, written to slot straight into the skeleton.

MY STANDARD SKELETON (scope language, pricing logic, terms):
[PASTE YOUR SKELETON HERE]

CALL NOTES OR TRANSCRIPT:
[PASTE CALL NOTES OR TRANSCRIPT HERE]

Using these, draft:
1. A client greeting using their actual name and company, taken only from the notes
2. A scope section that reflects what was actually discussed, written in the same tone and structure as the skeleton's scope language
3. Pricing, using the skeleton's pricing logic applied to what this client actually needs. Do not invent figures that aren't supported by the skeleton or the notes
4. A timeline based on any dates, deadlines or urgency mentioned in the notes

Rules:
- Do not touch or rewrite the terms section. Leave it exactly as in the skeleton
- If the notes don't mention something you need (budget, deadline, decision maker), flag it as [MISSING: describe what's needed] rather than guessing
- Keep sentences short. This is a business document, not marketing copy
- Output in four labelled sections matching the four points above, ready to paste under my skeleton's letterhead and terms

If anything in the notes contradicts the skeleton's standard scope, flag it clearly at the top before the four sections, so I catch it before this goes out.

This Week's Challenge

Open your last three proposals. Find the sentences that appear in all three, word for word. That's your skeleton.

Paste it into Claude with one real call transcript and ask it to draft the client-specific sections only. Names, scope, price, timeline.

You should have a working template by lunch, and your next proposal should take a fraction of the time the last one did.

SPONSORED Most Claude skills don't fail because the instructions are bad. They fail because the description is too vague to trigger reliably, a frontmatter field is missing, or the output format was never specified so Claude invents one. Skill-validator drops into a Claude project, reads your SKILL.md and returns a 0 to 10 score with the specific fix for every issue it finds. Scored one of mine a 4 and it was right about why. Free, permanently. Skill-validator

Forward this to one person who should be using AI better than they are. Reply with what you built, tried or broke this week. I read every one.

Gareth, founder of The Anthropic Stack (theanthropicstack.com)

Anthropic told TechCrunch this week how Claude's watermarking will actually work. Not the marketing version, the mechanism, and the detail that matters most got buried under the announcement itself. Watermarks survive generation. Fine, in theory. Here's the practical bit. They do not survive editing.

A watermark gets embedded in Claude's output at the token level, patterns invisible to a human reader but detectable by a checker that knows what to look for. Except code gets pasted into files, reformatted, refactored, mixed with human-written lines within the hour. Prose gets edited in Word. The watermark degrades with every touch, and most AI output gets touched immediately. So the tool everyone will point to as proof of AI provenance mostly proves provenance for the fifteen minutes before anyone does anything useful with the output.

I've spent ten years in crypto being told the technology I was using would fix trust problems it couldn't actually fix. Watermarking has the same shape. It's a good idea attached to a promise it can't keep. The honest framing is narrower: this catches unedited, wholesale copy-paste. It does nothing for the far more common case, a developer taking Claude's output and shaping it into something of their own. That's a limit of what watermarking can do at all, not a flaw in Anthropic's implementation.

Where this actually bites is procurement and compliance. If your business is being asked to prove code wasn't AI-generated, or a client wants assurance that a deliverable was, a watermark that vanishes after one edit is not the assurance anyone thinks they're buying. Expect this to surface in contracts before it surfaces in headlines. Someone will write "AI-generated content must be watermarked" into a supplier agreement this year. The first time a watermark fails to survive a routine edit, that clause is going to cause a very awkward call.

Anthropic deserves credit for publishing the mechanism instead of just the promise. Most vendors won't tell you where the seams are. This is where they are.

The Stack This Week

Anthropic's Own Agents Turned On Each Other Anthropic ran a study putting AI agents on the same task and watched them clash, collude and coordinate in ways nobody had specifically tested for, according to the research covered by TechCrunch. Multi-agent systems are the direction the whole industry is heading, with agents delegating to other agents rather than a single model doing everything. The problem is that safety testing has mostly assumed one model, one task, one set of guardrails. Put several agents in the same space competing for the same resource and you get behaviour nobody explicitly programmed. If you're building anything where multiple agents share a workspace, read this before you assume the safety testing that covers a single agent covers the interaction between several.

NVIDIA Built a Traffic Cop for Your AI Stack Switchyard (GitHub) is NVIDIA's answer to a problem most teams hit the moment they use more than one model provider: routing. It lets an application send requests across different models and vendors while staying compatible with both the OpenAI and Anthropic APIs. You're not rewriting your integration every time you switch who's doing the reasoning. It supports benchmarking and cost optimisation out of the box, which matters more than it sounds, because most work thrown at frontier models doesn't need frontier reasoning. A router that lets you send the cheap stuff to the cheap model is worth more than another benchmark chart. Coming from NVIDIA gives it a credibility most routing tools have to earn the hard way.

One Workspace, Every Agent You Run holaOS (GitHub) is an open-source workspace that runs Claude Code, Codex and other agents side by side, with over 100 integrations, MCP support and shared memory between them. It's picked up 6,502 stars, a real signal rather than a vanity one. Built in TypeScript, it's aimed squarely at developers running several agentic tools at once who are tired of switching context between them. Shared memory is the feature worth actually testing. Everything else on the list is table stakes now. Whether agents genuinely retain useful context across a session, or just claim to, is the thing worth finding out yourself.

Does a watermark that dies after one edit actually protect anyone?

Tell me in the comments.

Forward this to one person who should be using AI better than they are. Reply with what you built, tried or broke this week. I read every one.

Gareth, founder of The Anthropic Stack (theanthropicstack.com)

The Shiplog

• kepano/obsidian-skills (GitHub) - 45,636 stars for teaching your agent to speak Obsidian's language: Markdown, Bases, JSON Canvas, all through the CLI. Most agent integrations with knowledge tools are bolted on and brittle. This one respects the open formats Obsidian already uses. That means it survives an update instead of breaking on one. If you keep notes in Obsidian and want an agent that can actually read and write them properly, install this first.

• cathrynlavery/diagram-design (GitHub) - Twenty nine diagram types built specifically for Claude Code, self-contained HTML and SVG, no Mermaid in sight. Over 14,000 stars and 4,500 of those landed in a single day, which tells you how badly people wanted this. Every developer who's watched Claude generate a diagram that looks like it was drawn by a committee will get the appeal instantly. Clean output, no shadows, no dependency hell. Install it.

• superset-sh/superset (GitHub) - Run over 100 coding agents in parallel, Claude Code or Codex or any CLI agent you fancy, each one sandboxed in its own isolated environment. 12,889 stars and climbing, written in TypeScript. This solves a real problem: agents stepping on each other's file changes when you try to run more than one at once. Worth knowing about even if you never need a hundred agents running. Ten will do most of the damage you actually want.

• calesthio/OpenMontage (GitHub) - What happens when you point agentic AI at a genuinely hard domain instead of another chatbot wrapper. OpenMontage claims to be the first open-source agentic video production system, and it backs that claim with twelve production pipelines and over 100 tools, all in Python. Video is a brutal place to build agent workflows. Failure is visible and expensive to fix. If it holds up under real use, it's the most ambitious thing on this list by some distance.

• triggerdotdev/trigger.dev (GitHub) - A TypeScript framework for building and deploying fully-managed AI agents and workflows, sitting at 15,825 stars. Less flashy than most things on this list. Trigger.dev is infrastructure, not a demo. If you're past the "look what Claude can do" stage and into "this needs to run reliably every night without me watching it", this is the layer that gets you there.

The Take

Look at what actually got starred this week. Not another agent framework promising to orchestrate your life. Tools that plug an agent into something that already existed and worked: Obsidian's own formats, Claude Code's own output, a CLI you already run. The agent doesn't run the show any more. It's the connective tissue.

That matches what I keep telling clients when they ask why their AI project stalled after the demo. The demo works because a demo is scoped. Production fails because production means fitting into fifty things that already exist in the business, none of which were built with an agent in mind. OpenMontage is the outlier here, a system built from scratch for a hard domain, and it's the riskiest bet on this list precisely because of that. The safer money this week was on integration, not invention.

Which of the five would you actually run in production next week?

Tell me in the comments.

Forward this to one person who should be using AI better than they are. Reply with what you built, tried or broke this week. I read every one.

Gareth, founder of The Anthropic Stack (theanthropicstack.com)

P.S. Shipping something this week? Railway gives Anthropic Stack readers $20 in credits to start: theanthropicstack.com/railway. It is a referral link, so I earn a small cut if you stay. I only point you at tools I run myself.

The Weekly Build

Tool Teardown this week: Orca, an Agent Development Environment for running a fleet of coding agents in parallel instead of babysitting one at a time.

You've got several coding agents, all yours to run, and instead of queuing them up one after another, Orca lets you fire them off together and check back when they're done. It's on GitHub with over 42,000 stars, and the daily growth on that repo is not normal for something this young.

Getting started is easier than the star count makes it look. You don't clone it. It's a desktop app for Mac, Windows and Linux, so you download a build or install it with Homebrew, and then you point it at the coding agent subscriptions you already pay for. No new API keys, no separate billing. You're not paying twice for the same tokens, you're just running more of them at once.

What it's actually good at is throughput. Say you've got three small fixes, a test suite to write and a config change. Run that the old way and it's four sequential conversations, each waiting on the last one to finish. Orca kicks all four off together. You go make a coffee, and you come back to four finished jobs instead of one. There are iOS and Android companions as well, so the checking back can happen from your phone rather than from the desk you were trying to get away from.

It's built for people who already run an agent solo most days and have started to feel the ceiling, not for someone opening a coding agent for the first time.

What it's not good at is anything with dependencies between the tasks. If agent two needs to see what agent one just wrote, running them in parallel just hands you a merge conflict to untangle by hand later, which costs you more time than the parallel run ever saved. Orca is a tool for independent work, not a coordination layer. Don't mistake it for one.

And it's TypeScript, built fast, trending hard. Expect rough edges. That combination usually ships something useful a long time before it ships something polished, and I'd be surprised if Orca turned out to be the exception.

Who should use it: anyone already running Claude Code or something similar daily who's hit the point of doing one thing at a time and wanting more. If you haven't found your first agent workflow yet, skip this and come back once you have.

One line verdict: it does exactly what it says on the tin. If you're not already bottlenecked on sequential agent work you won't feel the difference yet, but you will eventually.

This Week's Challenge

Open Orca against a repo you already use with Claude Code. Pick three small, unrelated tasks, the kind you'd normally run one after the other without thinking about it. Run all three at once instead. Time it, then compare against your usual sequential habit.

Watch your own waiting time rather than the total runtime, because waiting is the number sequential working quietly inflates while nobody ever writes it down.

You'll come out with one of two things. A new default way of working, or a clear reason not to bother yet. Both are useful, and neither is a waste of fifteen minutes.

Try it and tell me in the comments what happened. I read every one.

Forward this to one person who should be using AI better than they are. Reply with what you built, tried or broke this week. I read every one.

Gareth, founder of The Anthropic Stack (theanthropicstack.com)

Claude Code is about to stop asking permission before it acts. Starting the 14th of August, auto mode becomes the default. Right now, when Claude Code wants to run a command or edit a file outside the obvious safe zone, it stops and asks. Soon it won't. It will just do the thing and tell you afterwards.

That's a bigger change than the wording lets on. Permission prompts are annoying. They're also the thing standing between "Claude edited a file" and "Claude ran a command you didn't read properly at 11pm and now something's broken." Removing the prompt doesn't remove the risk. It just moves the risk earlier, into the setup you did before you ever typed a task.

I don't think this is the wrong call. Most sessions never trip the dangerous path anyway, and asking permission fifteen times an hour trains people to click yes without reading, which is worse than no prompt at all. A permission system nobody reads is decoration.

But the maths only works if you did the boring bit first. Sandboxing, scoped credentials, a repo you can afford to have touched. Skip that setup and auto mode is a live gun with the safety off. You won't notice until it fires.

This is the same shape as every "the machine now acts without asking" moment I've watched roll through crypto for ten years. Custody, permissions, keys held by something that doesn't sleep. The industry always ships the capability first and the safety rail as a fast-follow. Sometimes that's fine. Sometimes it's how you get a very expensive Tuesday.

So here's the actual decision facing you before the 14th: is your Claude Code environment one you'd trust to run itself? Not "would I like it to." Would you trust it. If the honest answer is no, this is the week to fix that, not the week after something goes wrong.

The Stack This Week

Claude Code Sessions Can Now Talk to Each Other Claude Code (r/ClaudeAI) picked up a feature that lets separate sessions communicate with each other on macOS. Until now, each session was its own island. You'd run one agent on the backend and another on the frontend and neither would know the other existed. Cross-session communication opens the door to genuinely coordinated multi-agent workflows, rather than the current habit of running several Claudes and manually stitching their output together. It's early. Expect the first wave of workflows built on this to be clumsy before anyone works out the good patterns.

Someone Wired Their iPhone Into Claude Code A developer built native MCP tools (r/ClaudeAI) that let Claude Code reach into an iPhone's own capabilities. Camera, contacts, whatever the device exposes, now available as tools Claude can call directly. This is exactly what MCP was supposed to unlock: point the protocol at something that already has an interface, and skip building a new integration from scratch. Don't copy this into production tomorrow. It's a proof of what's possible, not a finished product, and the gap between those two things is most of the work.

The Anthropic Python SDK Adds Mid-Conversation Tool Changes Version 0.121.0 of the anthropic-sdk-python (GitHub) shipped a beta API for changing tools mid-conversation, plus support for session budgets and advisor tools. If you're building anything where the tool set needs to shift depending on what the conversation has become, this release lets you do it without restarting the session. Session budgets matter more than they sound. Cost control that lives in the SDK beats cost control you bolt on afterwards with a spreadsheet and a prayer.

Blender Now Takes Prompts Instead of Mouse Clicks blender-mcp (GitHub Topic: model-context-protocol) hands Claude control of Blender, the 3D modelling tool, through MCP. Prompt-driven modelling, materials, scene generation. Over 25,000 stars is not a small number for a repo this specific. It tells you the demand for AI inside creative tools is real, not speculative. Written in Python, easy enough to inspect before you trust it near your project files.

Would you trust your Claude Code setup to act without asking first? Tell me in the comments.

Forward this to one person who should be using AI better than they are. Reply with what you built, tried or broke this week. I read every one.

Gareth, founder of The Anthropic Stack (theanthropicstack.com)

The Shiplog

• browser-use/browser-use (GitHub) - Over 107,000 stars for a Python library that lets an AI agent click, scroll and read a website the way you would. Most sites still assume the visitor has eyes and a mouse, not an API key. This is the bridge for that gap. If you have ever tried to get an agent to fill in a form or scrape a page that fights back, this is the tool everyone converges on eventually. Worth running early rather than reinventing your own Selenium wrapper badly.

• upstash/context7 (GitHub) - Context7 solves a specific, boring, constant problem. The model's training data is always out of date and your dependencies are not. It's an MCP server from Upstash that pulls current documentation straight into the model's context, so it stops confidently suggesting a method that got deprecated two versions ago. 60,076 stars says this pain is universal. If you're pairing Claude with a fast-moving framework, this belongs in your setup rather than in a bookmark you meant to try.

• headroomlabs-ai/headroom (GitHub) - Everyone building with LLMs eventually hits the same wall. Tool outputs and RAG chunks are stuffed with tokens the model never needed. Headroom compresses logs, files and tool results before they reach the model, with a reported 20% reduction in tokens. That's not a huge number on its own. Stack it across every call in a production agent and it starts paying for the engineer who installed it.

• microsoft/ai-agents-for-beginners (GitHub) - Eighteen Jupyter notebooks from Microsoft, over 70,000 stars, and genuinely aimed at people who have not built an agent before. It's not Claude-specific and it won't teach you anything advanced. What it does well is give a structured on-ramp to a newcomer, which is rarer than it should be given how much of this space assumes you already know the vocabulary.

• HKUDS/nanobot (GitHub) - A lightweight, self-hosted personal agent framework in Python, tagged under the model context protocol topic and sitting at 46,472 stars. Self-hosted matters here. You keep the data, you keep the config. Nothing routes through someone else's dashboard. It's newer than the others on this list and the documentation shows it, so treat it as promising rather than production-ready until more people have kicked the tyres.

The Take

Look at what's actually getting starred this week and a pattern falls out. Almost none of it is about making the model smarter. It's about making everything around the model cheaper, faster or less annoying: compressing what you feed it, keeping its documentation current, giving it hands to use a website with. That tracks with something I say to clients constantly. Most work thrown at frontier models does not need frontier reasoning, and the tooling market has clearly noticed the same thing before most teams did. Nobody's shipping a smarter brain this week. They're shipping plumbing. And the plumbing is where the actual margin lives. A 20% token reduction across a busy agent is real money every single day. A marginally cleverer model is a line item you might not even use correctly.

Is your team optimising the model or the pipes around it?

Tell me in the comments.

Forward this to one person who should be using AI better than they are. Reply with what you built, tried or broke this week. I read every one.

Gareth, founder of The Anthropic Stack (theanthropicstack.com)

P.S. Shipping something this week? Railway gives Anthropic Stack readers $20 in credits to start: theanthropicstack.com/railway. It is a referral link, so I earn a small cut if you stay. I only point you at tools I run myself.

The Weekly Build

Most of what Claude can't do for you comes down to one thing. It can't see the web.

Ask it to check a price, pull a spec sheet or scrape a competitor's pricing page and it'll either refuse or make something up. That's a training cut-off problem, and every frontier model has one, with the gap between the cut-off and today only growing.

Firecrawl's MCP server fixes it. It gives Claude an actual scraping and search tool it can call whenever it needs to look at a live page, rather than guess from memory. Twenty minutes, no coding beyond copying a config file, and here's how.

1. Get a Firecrawl API key. Sign up at firecrawl.dev, and the free tier gives you enough credits to test this properly.

2. Open Claude Desktop's config file. On a Mac that's `~/Library/Application Support/Claude/claude_desktop_config.json`. On Windows it's in `%APPDATA%\Claude\`. If the file doesn't exist, create it.

3. Add the Firecrawl server, pasting this in with your own key:

{
  "mcpServers": {
    "firecrawl": {
      "command": "npx",
      "args": ["-y", "firecrawl-mcp"],
      "env": {
        "FIRECRAWL_API_KEY": "your-key-here"
      }
    }
  }
}

4. Restart Claude Desktop, and fully quit it rather than just closing the window.

5. Check the connection. Look for a small hammer icon near the message box, click it, and Firecrawl should be listed as an available tool.

6. Ask it to fetch something real. Try: "Go to (any public pricing page) and pull out every plan name and price into a table," then watch it call the tool rather than guess.

7. Push it further, asking it to scrape three competitor pages and compare them. This is where it earns its keep.

What you end up with is a Claude that reads the live web on request instead of working from a memory that's already months stale. Firecrawl's own server has passed 7,000 stars on GitHub, which tells you plenty of people are running this exact setup daily rather than trying it once and forgetting about it.

One warning, and it gets its own sentence because it matters: scraping sites you don't own can breach their terms of service. Stick to your own pages and public data until you've checked.

This Week's Challenge

Open Claude Desktop with Firecrawl connected and ask it to scrape your own homepage, listing every claim you make about turnaround time or pricing. Fifteen minutes gets you a plain list of what your own site promises a customer, in writing, whether you meant it to or not.

Worth knowing before someone else finds it first.

Try it and tell me in the comments what happened. I read every one.

Forward this to one person who should be using AI better than they are. Reply with what you built, tried or broke this week. I read every one.

Gareth, founder of The Anthropic Stack (theanthropicstack.com)

Something shifted this week. Not another model release, but the infrastructure underneath. AWS shipped an MCP server. Unity got one. So did a code search tool built on a vector database company's stack. None of that is glamorous. All of it matters more than whatever benchmark chart did the rounds on Monday.

Here's the thing people miss about the Model Context Protocol. It was never really about Claude talking to more tools. It was about who builds the bridge and who has to maintain it forever afterwards. When AWS Labs puts its name on an MCP server, Amazon is deciding this protocol is worth institutional weight, not a side project some engineer built over a weekend and abandoned. The same goes for a game engine vendor letting an LLM reach into the Unity Editor. A company has decided its product needs an AI-shaped front door. That's a real signal, not a toy demo.

The pattern worth watching is who's building these and why. AWS is in. So is Prefect, so is a search infrastructure company, so is an open source coding toolkit that grew a community without any of that backing at all. Anthropic barely features. MCP won by becoming boring enough that unrelated companies build on it without asking permission first. Nobody announces it. It just starts turning up in places you didn't expect.

The number that should stop you is the star count on some of these. A toolkit built as a coding IDE substitute, from a small studio, sitting past 27,000 stars. Thousands of developers decided a tool solved something painful enough to bother starring it, and that's a much higher bar than clicking a link in a newsletter.

Traction like that is a filter, not a discovery. A repo with no stars and no commits tells you nothing. A repo with tens of thousands does. This week gave us five that cleared it, and every single one came from a different corner of the stack: cloud infrastructure, game development, code search, developer tooling, and the raw framework underneath all of it.

The Stack This Week

AWS Puts Its Name Behind an MCP Server AWS Labs MCP (GitHub) is exactly what it sounds like: an official, open source MCP server implementation from Amazon, sitting at 9,523 stars. It lets Claude and other MCP clients talk to AWS services directly, which matters more than the star count suggests. AWS doesn't put its name on side projects. When a company this size ships infrastructure for a protocol, it's telling developers the protocol is safe to build a business on. That's a different signal from a startup's weekend release. Treat this as the moment MCP stopped being an Anthropic bet and started being shared plumbing.

A Coding IDE Built Entirely on MCP 27,000 stars is a serious number for anything, and Serena (GitHub) has earned it. It's a Python-based MCP toolkit that does semantic code retrieval and editing, positioned to function like an IDE rather than a bolt-on. Developers using Claude for coding work have been asking for exactly this: something that understands a codebase's structure, not just its text. A community voted with stars because the tool solved a real problem.

Your Whole Codebase, Not Just the Open File Context is the thing that breaks Claude Code on large projects, and Claude Context (GitHub) from Zilliz goes straight at it. Built in TypeScript, it lets you use an entire codebase as context for a coding agent rather than whatever fits in a single prompt window. Over 12,000 stars back it up. The pain point is real. Anyone who's watched Claude lose track of a function defined three files away knows exactly why this exists. Worth a look if that's been your ceiling.

Prefect's Python Framework for Building MCP Servers Nearly 27,000 stars, and it comes from an established team rather than an unknown. FastMCP (GitHub), built by PrefectHQ, gives Python developers a proper framework for building MCP servers and clients rather than hand-rolling the protocol themselves. This is the least visible item on this list and probably the most useful one. Every server above needed something like this underneath it. If you're building your own MCP integration rather than just using someone else's, start here.

Where do you think MCP goes next now that AWS and Unity are building on it too?

Tell me in the comments.

Forward this to one person who should be using AI better than they are. Reply with what you built, tried or broke this week. I read every one.

Gareth, founder of The Anthropic Stack (theanthropicstack.com)

The Shiplog

• langgenius/dify (GitHub) - 144,296 stars. This is a production-ready platform for building agentic workflows without writing the orchestration layer yourself, and it's the open source answer to the proprietary agent builders. That star count says a lot of teams have already made the swap. Written in TypeScript, so it plugs into the stack most of you already run. Evaluating agent infrastructure? Close this gap first.

• alibaba/open-code-review (GitHub) - Alibaba open sourced the code review tool it runs internally, and for anyone shipping software daily, this is the most useful thing on the list. It mixes deterministic pipelines with LLM agents, supports both OpenAI and Anthropic models, and comes with rulesets for the security issues that actually show up in real codebases. Battle-tested at Alibaba's scale is a claim worth taking seriously, because most code review tools are battle-tested at nobody's scale. Wire this into your CI and you get a second reviewer that never gets tired on a Friday afternoon.

• obra/superpowers (GitHub) - 219,579 stars and still trending, with over a thousand new stars in a single day. It bills itself as an agentic skills framework and a development methodology, written in Shell. The traction is real. What's thin is the detail on how it actually integrates with the tools most of you are running, so go in expecting to do some reading before you know if it fits your workflow.

• earthtojake/text-to-cad (GitHub) - Nearly 10,000 stars for agent skills built specifically for CAD, robotics and hardware design. This is the interesting kind of agentic tooling, the kind that goes deep on one domain instead of promising to do everything. Most agent frameworks stop at writing code and answering emails, but this one is aimed at people building physical things. A much smaller, much more useful lane.

• huggingface/speech-to-speech (GitHub) - Hugging Face's repo for building local voice agents on open source models picked up 627 new stars in a single day, which tells you where developer attention is heading next. Voice is the interface everyone keeps predicting and nobody quite ships. This gets you local, which matters if you care about latency, or if you don't want your users' voices going to a third-party API. Early days. Clone it and run it yourself before you decide it's not for you.

The Take

The Latent Space piece on ontologies making a comeback is worth sitting with, because it names something I keep seeing without a name for it. Agents are probabilistic. Businesses are not. You cannot ship a support workflow that's right ninety per cent of the time and shrug at the other ten, and better models won't fix that. What fixes it is a harder boundary around what the model's allowed to decide.

Same lesson, buried in Alibaba's code review tool this week. It doesn't let the LLM freewheel over a diff. Deterministic rules run first, and only the ambiguous cases go to the agent. Match the model to the job. Don't ask frontier reasoning to do what a rule could do for free.

The ontology crowd spent a decade being told the semantic web was dead, and it turns out it was just early. I've heard that one before.

Have you built a hard boundary around an agent this week, or are you still trusting the prompt?

Tell me in the comments.

Forward this to one person who should be using AI better than they are. Reply with what you built, tried or broke this week. I read every one.

Gareth, founder of The Anthropic Stack (theanthropicstack.com)

P.S. Shipping something this week? Railway gives Anthropic Stack readers $20 in credits to start: theanthropicstack.com/railway. It is a referral link, so I earn a small cut if you stay. I only point you at tools I run myself.

The Weekly Build

Medical bills. Insurance denials. Council tax bands. Energy tariffs. Every household gets paperwork built to be too confusing to challenge. Most people pay it. Not because the charge is right. Because working out whether it's wrong takes an evening they don't have.

That's the process worth automating this week. Not a business one. Yours.

Here's the before. A wrong or inflated bill turns up. It's covered in codes. Maybe a CPT code, maybe a tariff band, maybe an itemised list that means nothing to anyone without a coding manual. You've got three options. Pay it. Call and get nowhere for forty minutes. Or spend an evening cross-referencing the provider's own fee schedule, hoping you spot the error yourself. Most people take option one. It's the only one that doesn't eat an evening.

Someone on r/ClaudeAI took a different route. A $1,200 medical bill went into Claude, itemised codes and all, with a simple ask: explain each line, flag anything that looks wrong or negotiable. Claude drafted the dispute letter. The bill dropped to $180.

The method behind it works on far more than medical bills, and you can run it this week:

1. Photograph or type out every line item and code on the bill.

2. Ask the model to explain what each code actually means, in plain English.

3. Ask it to flag anything duplicated, upcoded, or not matching the service you actually received.

4. Ask it to draft a formal dispute letter citing the specific discrepancies it found.

5. Send the letter. Keep the model's explanation as your own notes for the follow-up call.

Match the model to the job. This doesn't need frontier reasoning. It needs something that reads a fee schedule carefully and doesn't skip lines. Claude or ChatGPT both do this fine, and there's no reason to pay ceiling price for it.

A $1,020 reduction from one letter is the number as reported. Not typical. Not guaranteed. But the pattern behind it holds: itemised bills are full of charges billed at the wrong rate or the wrong code, and almost nobody checks.

One thing trips people up. The model needs the actual codes, not a vague description. "It's about $1,200 for a scan" gets you nothing useful back. The CPT code and the amount charged gets you a proper answer, and a letter worth sending.

Try it on the next bill you were about to just pay.

This Week's Challenge

Find one bill, invoice or statement you've been putting off checking. Medical, phone contract, council charge, doesn't matter. Photograph the line items and paste them into Claude or ChatGPT. Ask it to explain each charge in plain English and flag anything that looks wrong. Fifteen minutes, that's it. You'll either come away with peace of mind or a letter worth sending.

Try it and tell me in the comments what happened. I read every one.

Forward this to one person who should be using AI better than they are. Reply with what you built, tried or broke this week. I read every one.

Gareth, founder of The Anthropic Stack (theanthropicstack.com)

Anthropic launched Opus 5 this week, and the framing is unusually blunt for a company that normally guards its language carefully. Reports describe it as cheaper and less restrictive than Fable, Anthropic's other frontier model, while landing close to Fable's actual capability in many domains. That is an odd position for a company to put itself in. Anthropic is effectively telling customers that its flagship reasoning model and its newer, cheaper model now sit close enough together that the expensive one is a harder sell.

This matters more than the usual "new model, bigger benchmark" cycle. For years, the pattern from every major lab has been simple: the most capable model costs the most, and you pay the premium if you need the ceiling. Opus 5 breaks that pattern deliberately. If a model priced well below the top tier delivers results close to it, the economics of choosing a model stop being about chasing the best possible output and start being about matching the model to the job. Most tasks people throw at frontier models, drafting emails, summarising documents, writing routine code, do not need frontier reasoning. They need reliable output at a sensible cost. Opus 5 is a bet that most of Anthropic's revenue sits in that zone, not at the ceiling.

There is a second layer here worth noting. The release lands shortly after regulatory scrutiny and industry security incidents affecting the wider AI sector. Launching a cheaper, less restrictive model into that environment is a statement of confidence, or at least a calculated one. "Less restrictive" is doing a lot of work in that sentence, and Anthropic has not published a detailed account of what specifically loosened. Businesses evaluating Opus 5 for anything touching compliance, content moderation or customer facing use should treat that phrase as a prompt to test thoroughly rather than assume equivalence with previous safety behaviour.

The practical takeaway for anyone using Claude commercially: do not default to the most expensive model out of habit. Opus 5 is designed to make that decision less obvious than it used to be, and the businesses that benefit will be the ones that actually test both models against their own workloads rather than assuming price maps neatly to quality.

The Stack This Week

Claude Voice Mode Expands Beyond Haiku Anthropic has extended voice mode to Claude Opus and Sonnet (https://www.theverge.com/ai-artificial-intelligence/970065/anthropic-voice-mode-claude-opus-sonnet-haiku-ai), having previously restricted it to Haiku. The expansion comes alongside integration into third party apps including Gmail, Slack and Canva. For businesses building voice interfaces, this removes a real constraint: previously, choosing voice meant accepting the smallest, least capable model in the lineup. Now the reasoning tier and the voice tier are no longer locked together, which changes what is realistically buildable. Worth testing before committing, since integration quality inside Gmail, Slack and Canva will vary and Anthropic's own blog post has not detailed latency or accuracy differences across the tiers.

Claude Code's System Prompt Cut by Over 80 Percent A developer on Twitter reported (https://twitter.com/trq212/status/2080710971228918066) that Anthropic removed more than 80 percent of Claude Code's system prompt for the Opus 5 and Fable 5 models. System prompts are the hidden instructions that shape how a coding assistant behaves before it ever sees your request, and a cut this large suggests the underlying models now need far less hand holding to behave correctly. That is a meaningful signal about model quality, not just tidying. Fewer instructions generally means fewer edge cases where the model ignores or misapplies guidance, though this claim comes from a third party observation rather than an official Anthropic statement, so treat it as a strong signal rather than confirmed fact until Anthropic documents it directly.

Tree of Thought Reasoning Gets a Popular Open Source Implementation ADHD (https://github.com/UditAkhourii/adhd), a GitHub project with 2,353 stars, implements tree of thought reasoning with pruning as a skill for coding agents built on the Claude and Codex Agent SDKs. In plain terms, instead of a coding agent committing to one line of reasoning, it explores several branches and prunes the weaker ones before settling on an answer. Written in TypeScript, it is aimed squarely at developers building agentic coding tools rather than end users. The star count suggests genuine developer interest, though as with any community project, expect rough edges and check recent commit activity before depending on it in production.

Do you think a cheaper Opus 5 changes which Claude model you would default to for everyday work? Tell me in the comments.

Forward this to one person who should be using AI better than they are. Reply with what you built, tried or broke this week. I read every one.

Gareth, founder of The Anthropic Stack (theanthropicstack.com)

The Shiplog

• AstrBotDevs/AstrBot (GitHub Trending) - An open source Python framework for building AI agent assistants that plugs into multiple instant messaging platforms, connects to various LLMs and supports a plugin system. It has passed 36,000 GitHub stars, which puts it firmly in the conversation as an alternative to OpenClaw for anyone building chat based agents. The star count is a real adoption signal, though the summary available this week does not detail its specific Claude integration depth. Worth a look if you are choosing a messaging first agent framework, but check the docs yourself before committing production time to it.

• modelcontextprotocol/typescript-sdk (GitHub) - The official MCP TypeScript SDK shipped a beta release of its legacy server package, updating dependencies on the core MCP library. This is unglamorous plumbing work, but it comes straight from the modelcontextprotocol organisation, which means it is the ground truth for anyone building MCP servers in TypeScript. If you maintain an MCP server on this SDK, pull the update and check nothing downstream breaks before you push to production. Not exciting, but exactly the sort of release you should never ignore.

• anthropics/anthropic-sdk-typescript (GitHub) - A bug fix release for the Anthropic TypeScript SDK's AWS integration, version 0.6.1, resolving an issue where AWS options and authentication mode were not preserved across `withOptions()` calls. If you are running Claude through AWS in production, this is the kind of quiet fix that saves someone a very bad afternoon debugging authentication that silently drops. Update now rather than discovering the bug in an incident review.

• No auth ramen MCP server (r/ClaudeAI) - A developer built an MCP server exposing a database of over 62,000 Japanese ramen shops across all 47 prefectures, with no authentication required to connect. It is a niche project, but it is a genuinely useful worked example of building and shipping a public, no auth MCP server that Claude can query directly. If you have been meaning to learn MCP server development, this is a clean, low stakes template to study before you build something with actual business data behind it.

• AMD's five billion dollar bet on Anthropic (The Verge) - AMD announced a commitment of up to $5 billion in Anthropic, alongside supplying AMD Instinct MI450 AI GPUs and Helios rack scale systems to expand Anthropic's computational capacity. This is not a developer tool, but it is direct evidence of the hardware backing behind Claude's future capacity and pricing. Anyone building a product roadmap on top of Claude should treat this as a signal that Anthropic is securing compute at scale, not scrambling for it.

The Take

Three of this week's items are version bumps and infrastructure deals, not new capabilities. That is the story most people will miss. AMD committing up to $5 billion in compute, a quiet AWS authentication fix in the Anthropic SDK, and a legacy MCP server dependency update look unrelated on the surface. They are the same signal read at different altitudes. Anthropic is building the plumbing to be depended upon at industrial scale, and the unglamorous maintenance releases are the proof, not the compute deal. Anyone can announce a billion dollar infrastructure partnership. Far fewer organisations fix `withOptions()` authentication bugs within point releases because production customers noticed and complained. That is what a mature platform looks like from the inside. Meanwhile the flashiest developer item this week, a 36,000 star agent framework, tells you where community attention sits, but attention and dependability are not the same currency. If you are choosing what to build on, watch the boring releases more closely than the star counts.

Which matters more to you when choosing an AI platform, the compute backing it or the quality of its maintenance releases? Tell me in the comments.

Forward this to one person who should be using AI better than they are. Reply with what you built, tried or broke this week. I read every one.

Gareth, founder of The Anthropic Stack (theanthropicstack.com)

P.S. Shipping something this week? Railway gives Anthropic Stack readers $20 in credits to start: theanthropicstack.com/railway. It is a referral link, so I earn a small cut if you stay. I only point you at tools I run myself.

The Weekly Build

Every AI agent that needs to research something on the internet faces the same choice. Pay for an API like Perplexity or Tavily, or develop your own scraper and hope it does not break the first time a website changes its layout. Wigolo (https://github.com/KnockOutEZ/wigolo), a local first web search, fetch and crawl tool built for AI coding agents, sits in the middle of that choice, and it is worth ten minutes of your time to understand why.

What it does. Wigolo gives AI agents the ability to search, fetch and crawl web content without depending on a cloud API. It operates entirely on your own machine, which removes the per request cost and the rate limits that come with commercial search APIs.

Getting it running. Clone the repository from GitHub at KnockOutEZ/wigolo. Install the dependencies with npm or yarn. Configure it as an MCP server, which is the connector standard that lets tools like Claude Desktop call external services directly. The documentation covers this integration specifically. You will need Node.js installed before starting. If you have configured an MCP server before, expect around ten minutes. If this is your first one, allow longer and do not rush the configuration step.

Where it delivers. For straightforward HTML pages, the crawl and fetch functions perform well. Pulling data from a documentation site, a news page or a public repository works cleanly, and the MCP integration means Claude calls it as a natural part of a workflow rather than a bolted on extra step.

Where it falls short. JavaScript heavy websites are a problem. If the content you need only appears after client-side rendering, Wigolo returns an empty page. There is no handling for authentication, so anything behind a login is inaccessible. The search function relies on local indexing rather than a proper search engine, so it lacks the sophistication of a commercial alternative. The project remains in public beta, so crawl behaviour can be inconsistent on certain sites and undocumented edge cases do appear.

Who this suits. Developers building agents that need web access without per request costs or API quotas should test it. Anyone prototyping a research assistant or an internal tool that fetches public data will find it useful. It is not ready for production systems that require reliability guarantees, and it will not handle complex web interactions.

The verdict. Genuinely useful for the specific problem it solves. Do not expect it to replace a proper search API for anything that matters commercially.

This Week's Challenge

Clone KnockOutEZ/wigolo from GitHub and configure it as an MCP server in Claude Desktop. Once connected, ask Claude to fetch and summarise a public documentation page or news article using Wigolo instead of its built in browsing. Note how it handles a simple HTML page compared with a JavaScript heavy site. This tells you exactly where the tool is useful for your own projects and where you still need a commercial API.

Try it and tell me in the comments what happened. I read every one.

Forward this to one person who should be using AI better than they are. Reply with what you built, tried or broke this week. I read every one.

Gareth, founder of The Anthropic Stack (theanthropicstack.com)

The biggest AI story this week is not a new model. It is a shift in what agents are allowed to touch. Computer-use, the ability for an AI system to operate a mouse, click through applications and control a desktop the way a person would, has moved from research demo to something developers are actively building fleets around. The open-source project trycua/cua has collected over 20,000 stars on GitHub, offering drivers and cross-OS fleet management specifically for scaling this kind of automation.

That number matters more than it looks. GitHub stars are a poor measure of revenue or reliability, but they are a decent measure of developer attention, and 20,000 stars on an infrastructure project signals that a meaningful chunk of the developer community has decided computer-use is worth building on now, not later. For context, most agent tooling projects that get traction are wrappers around an API call. This one is drivers and benchmarks for controlling actual operating systems at scale.

The practical implication is straightforward. Until recently, if you wanted an AI agent to operate software that had no API, your options were limited and mostly fragile. Screen scraping, brittle scripts, constant babysitting. Computer-use changes the economics because the agent operates the interface directly, the same way a human employee would. That means legacy software, internal tools with no integration path and desktop applications that will never get an API become automatable.

The catch, and it is a significant one, is reliability at scale. Controlling one desktop reliably is achievable today. Controlling a fleet of them, across different operating systems, for a business process that cannot tolerate failure, is a different problem entirely. Benchmarks and open-source drivers help developers evaluate this honestly rather than relying on vendor demos, which is exactly why a project like this matters more than another chatbot wrapper.

For SME owners watching from a distance, the signal is this. The tools to automate desktop based workflows, the ones your accounts team or operations team still does by hand in some ageing piece of software, are becoming genuinely viable. Not this quarter. But the infrastructure being built right now is what will make it possible within the next year, and it is worth understanding before a vendor sells you the packaged version at a markup.

The Stack This Week

Claude Code Draws Sharp Community Criticism A widely discussed post on Hacker News (https://www.olafalders.com/2026/07/17/claude-code-anatomy-of-a-misfeature/) picked apart a specific design decision in Claude Code, gathering 140 points and 119 comments. The scale of engagement matters more than the specific complaint. When a critical post about a developer tool generates that much discussion, it usually means the author has articulated a frustration many people already felt but had not put into words. Anthropic ships Claude Code fast and iterates in public, which is admirable, but it also means rough edges surface in exactly this kind of post before they get fixed. Worth reading if you use Claude Code daily, if only to see whether the pain point applies to your own workflow.

A Spare Mac Becomes a Claude Code Testbed A step-by-step tutorial (https://ykdojo.github.io/claude-controls-mac/) walks through setting up an old Mac specifically so Claude Code can control it, and it struck a nerve on Hacker News with 239 points and 171 comments. This sits in the same territory as the computer-use story above, but at the individual developer level rather than the fleet level. It is a genuinely practical guide rather than a thought piece, which likely explains the engagement. Anyone with a spare machine gathering dust now has a concrete reason to plug it back in.

Capital One Ships an Agentic Security Tool Capital One released VulnHunter (https://www.capitalone.com/tech/open-source/announcing-vulnhunter/), an agentic AI tool built to identify vulnerabilities in code. It matters less because of what the tool does specifically and more because of who shipped it. A major financial institution putting an agentic pattern into production for security analysis, and open sourcing it, is a strong signal about where regulated industries are willing to trust AI agents. Worth watching for developers curious how agentic workflows hold up under the scrutiny a bank applies before anything ships.

Anthropic Patches Its TypeScript SDK Google Cloud Integration Anthropic released v0.0.6 of the Google Cloud SDK component within its TypeScript SDK (https://github.com/anthropics/anthropic-sdk-typescript/releases/tag/google-cloud-sdk-v0.0.6), primarily updating the google-auth-library dependency. This is routine maintenance rather than news, but routine maintenance is exactly what breaks production applications when ignored. If you run Claude through Google Cloud in a TypeScript codebase, this is a five minute dependency bump, not a five month migration.

Do you think desktop automation will replace more software integrations than APIs do in the next year? Tell me in the comments.

Forward this to one person who should be using AI better than they are. Reply with what you built, tried or broke this week. I read every one.

Gareth, founder of The Anthropic Stack (theanthropicstack.com)