Latest / Braid / The Cost of Finding Out

Transcript

The Cost of Finding Out · Braid

• 0:04
  Anthropic spent this week drawing two lines around who gets to use Claude, and how.
• 0:08
  They point at the same thing from opposite ends, so let's take them together.
• 0:13
  The first line is a product launch: Claude for Small Business.
• 0:17
  It's a package of connectors and prebuilt workflows that drops Claude straight into the tools a small business already runs on — QuickBooks, PayPal, HubSpot, Canva and a handful of others.
• 0:28
  You toggle it on inside Claude Cowork, connect your stack, and pick a job.
• 0:33
  It ships with fifteen ready-to-run workflows and fifteen skills, built around the chores owners told Anthropic eat their evenings: planning payroll, closing the month, chasing overdue invoices, and running a campaign.
• 0:46
  Claude does the work, and you approve before anything sends, posts, or pays.
• 0:50
  Daniela Amodei, Anthropic's president, framed it as a gap-closer.
• 0:54
  Small businesses are about forty-four percent of US GDP and employ nearly half the private-sector workforce — but, in her words, their use of AI 'often stops at the chat window.' There's a ten-city road tour attached, a free fluency course run with PayPal, and Claude credits routed through community development lenders.
• 1:14
  As much as anything Anthropic has shipped, it's a distribution play aimed at people who are not us.
• 1:19
  And it isn't a thin one.
• 1:21
  Over on Hacker News, a developer named arjie described already doing exactly this shape of work.
• 1:27
  He'd wired Claude Code to his synced mail, a read-only banking token, and his accounting ledger — matching invoices to expenses and categorizing them.
• 1:36
  His framing was the useful part: these are tractable, checkable problems, where a miscategorization is something you'll catch because you're already looking.
• 1:45
  That's the real product here.
• 1:47
  Not magic — a clerk for the checkable stuff.
• 1:50
  The second line landed the same week, and it's very much aimed at us.
• 1:54
  A screenshot went around Reddit — close to eight hundred upvotes in a day — under the headline 'Anthropic pulled the plug on all programmatic use of Claude subscription.' That headline overshoots, so here's the actual change.
• 2:07
  Starting June fifteenth, some programmatic usage no longer draws from your normal subscription limits.
• 2:13
  That covers the Agent SDK — the toolkit for driving Claude programmatically — plus claude dash p, the headless mode in Claude Code, Claude Code's GitHub Actions, and any third-party agent built on that toolkit.
• 2:26
  Instead, it draws from a separate monthly bucket Anthropic is calling an Agent SDK credit.
• 2:31
  The credit is billed at API rates and worth somewhere between twenty and two hundred dollars depending on your plan.
• 2:38
  It doesn't roll over.
• 2:40
  Burn through it and you can't fall back on your general subscription quota — you buy more credits.
• 2:46
  So it isn't a ban.
• 2:47
  It's a meter.
• 2:48
  And you can steelman it without much effort: a flat monthly subscription was always priced around an interactive human typing at a chat window, not around someone running a fleet of headless agents through the weekend.
• 3:01
  Somebody was always going to pay for that gap, and moving programmatic use onto API-rate metering is the coherent version of the thing.
• 3:09
  The part that grates — and the Reddit thread is full of this — is the churn.
• 3:13
  One commenter, dbbk, just asked: 'What is this, the sixth u-turn?' Over the last couple of months Anthropic has blocked third-party agents on subscriptions, briefly pulled Claude Code off the twenty-dollar Pro plan, walked that back, and now landed here.
• 3:29
  Each move might be individually defensible.
• 3:31
  The sequence still costs them something real, because the thing a developer needs from a pricing page is the ability to plan against it.
• 3:39
  Another commenter posted a workaround within the hour — run actual Claude Code sessions inside tmux, drive them with sendkeys, clear and relaunch with hooks — which tells you people will route around the meter the second it pinches.
• 3:53
  Put the two lines next to each other and you get a quiet piece of strategy: a guided, approval-gated lane for the owner who never leaves the chat window, and a metered lane for the people leaning on the tool hardest.
• 4:06
  I don't think either is wrong.
• 4:08
  The one I'd read closely is the Agent SDK credit math when it goes live on June fifteenth — because if you've built anything that shells out to claude dash p in a loop, that's the day your cost model changes.
• 4:21
  Here's a sentence I didn't expect to write this week: most of Bun has been ported from Zig to Rust, and a large language model did the bulk of the typing.
• 4:31
  Some context.
• 4:32
  Bun is the JavaScript runtime and toolkit — the fast alternative to Node — and from the start it's been written in Zig, a young systems language still short of a one-point-oh release.
• 4:44
  Bun's creator, Jarred Sumner, has been one of Zig's most visible boosters for years.
• 4:49
  So when a pull request titled 'Rewrite Bun in Rust' showed up on the oven-sh repo, it got attention.
• 4:56
  Armin Ronacher — the person behind Flask — reposted it with three words: 'Say what you want, this is impressive.'
• 5:07
  Sumner wrote a Zig-to-Rust porting guide — roughly three hundred rules — and a two-phase plan.
• 5:14
  Phase A: translate the logic faithfully, without worrying about whether it compiles.
• 5:19
  Phase B: make it build, crate by crate.
• 5:22
  Then he pointed Claude at it.
• 5:24
  The working branch is literally named claude slash phase-a-port, and it holds something like nine hundred and sixty thousand lines of AI-generated Rust sitting next to the original Zig.
• 5:36
  Theo Browne, reading the diff, counted around thirteen thousand unsafe blocks still in it.
• 5:42
  The pull request that's live now claims something strong.
• 5:45
  It says the Rust port passes Bun's existing test suite on all platforms.
• 5:50
  Along the way it fixes several memory leaks and flaky tests, shrinks the binary by three to eight megabytes, and benchmarks somewhere between neutral and faster.
• 6:01
  You can run it today with bun upgrade canary.
• 6:04
  The stated reason for the whole exercise is one line: the team now has compiler-assisted tools for catching and preventing memory bugs, which, in their words, 'have costed the team an enormous amount of development and debugging time over the years.'
• 6:24
  On Hacker News he called the discourse an overreaction.
• 6:27
  'We haven't committed to rewriting,' he wrote.
• 6:31
  'There's a very high chance all this code gets thrown out completely.
• 6:35
  I'm curious to see what a working version of this looks like, what it feels like, how it performs.' So you have a maintainer who, in the same week, shipped a canary build that passes the full cross-platform suite and told everyone not to read too much into it.
• 6:52
  Both of those are true at once, and that's where this actually sits.
• 6:57
  A couple of threads here.
• 6:58
  One: Anthropic acquired Bun late last year, and uses it inside Claude Code.
• 7:03
  Zig has a stated no-AI-contributions policy.
• 7:06
  You can see why an AI company maintaining a runtime might be curious about a language that welcomes the tools it sells.
• 7:14
  Two: those thirteen thousand unsafe blocks.
• 7:17
  The pitch for Rust here is memory safety you get for free from the compiler — but unsafe is exactly the escape hatch where that guarantee switches off.
• 7:27
  A faithful, Phase-A translation of a Zig codebase is going to be wall-to-wall pointer arithmetic, and wrapping it in unsafe is how you get it to compile fast.
• 7:37
  Turning those into properly safe Rust is the work that's left, and it's not the part an agent finishes in six days.
• 7:44
  What I keep coming back to is the shape of the experiment, not the verdict on it.
• 7:50
  A million-line systems rewrite used to be a multi-quarter, bet-the-company decision.
• 7:55
  Sumner ran it as a curiosity — write the guide, point the agent at it, see how it feels — and got far enough in a week that the output runs and passes tests.
• 8:06
  The port itself might still get thrown away.
• 8:08
  The cost of finding out is what dropped, and that's a different number than it was a year ago.
• 8:15
  If you've ever been tempted to solve a problem by inventing a language, this next one is for you.
• 8:21
  Matija Sosic, who builds the full-stack web framework Wasp with his twin brother, published a post this week with a title that doesn't hedge: 'Five years and five million dollars later, inventing a new programming language for web development was a mistake.'
• 8:39
  Think Rails or Laravel, but for the JavaScript world, and stretched across the frontend too.
• 8:45
  The Sosic brothers came out of Y Combinator in 2021 with a specific frustration: every new web project meant re-stitching the same stack — React, the router, the state layer, auth, the build tool — and no single system understood the whole app.
• 9:00
  Their fix was a high-level spec.
• 9:02
  You'd declare it all in one place — Google and GitHub auth, a route that requires a logged-in user, a job that runs every day at five — and Wasp would generate the wiring.
• 9:12
  Your actual logic still lived in React and Node.
• 9:15
  The wrong turn, by Matija's own account, was deciding that spec had to be a brand-new language with its own compiler.
• 9:23
  They had reasons — full control over the syntax, and a vision of being runtime-agnostic someday.
• 9:29
  They're Haskell people, and a compiler was the fun nail for their functional hammer.
• 9:34
  It worked, technically.
• 9:35
  But the post is a clear-eyed walk through the cost of that choice, and most of the cost wasn't technical.
• 9:42
  The first cost was positioning.
• 9:44
  The name was wasp dash lang.
• 9:46
  Every developer who saw that read it as 'this wants to replace JavaScript' — which it never did, you still wrote ninety percent of your code in React and Node.
• 9:55
  But, in Matija's words, 'the notion of the lang suffix was simply too strong.' It put Wasp straight into the 'looks cool, too early' bucket.
• 10:04
  Their GitHub language bar said Haskell ninety percent, which reinforced exactly the wrong story.
• 10:10
  He calls it, with some pain, 'a perfectly executed wrong positioning.'
• 10:19
  Not users complaining — users who tried Wasp mostly liked it.
• 10:23
  The problem was internal.
• 10:25
  Matija writes that they underestimated how much work custom-language tooling takes — especially editor support.
• 10:31
  The bar developers expect today, in the JavaScript world, is incredibly high.
• 10:36
  They built their own language server and a VS Code extension and still only got to about eighty percent of where they wanted to be.
• 10:44
  The entire ecosystem assumes standard JavaScript and TypeScript.
• 10:48
  Step outside it, and you're rebuilding autocomplete from scratch.
• 10:52
  So they're switching the config language to TypeScript, and here's the line that's the payload of the post: 'Language was never the moat.
• 11:01
  It's having a high-level understanding of your entire app at compile time.' They had conflated language and specification — treated them as synonyms.
• 11:10
  It took five years of watching people use the thing to see that users were excited about the spec: the single source of truth about how the whole app fits together.
• 11:20
  Not the syntax.
• 11:21
  The syntax was a tax they were charging themselves.
• 11:25
  I think this generalizes well past web frameworks.
• 11:28
  The instinct to build the clean, controlled, bespoke thing — your own config format, your own DSL, your own protocol — is strong, and it usually feels like rigor.
• 11:38
  What this post documents is the part that doesn't show up in the design doc: the multi-year tail of tooling, onboarding friction, and positioning damage that rides along with leaving the paved road.
• 11:50
  Sosic ends on the AI angle, and it's a fair one — agents do better against a structured, opinionated spec than a pile of loosely-coupled libraries.
• 11:59
  But that argument never needed a new language.
• 12:02
  It just needed the spec.
• 12:04
  There's a talk from the AI Engineer conference I want to put in front of you, because it's one of the cleanest demonstrations I've seen of using a large language model by deliberately not letting it think.
• 12:15
  It's from Anant Dole and Asbjørn Steinskog, who build the chess app for Play Magnus — Magnus Carlsen's company.
• 12:22
  The product is a coach: you finish a game, and it gives you plain-English commentary on your moves — why a move was brilliant, what threat you missed, and what you should have played.
• 12:32
  The obvious way to build that is to hand the position to a model and ask it to explain.
• 12:37
  And that doesn't work, because large language models are famously bad at chess.
• 12:42
  They play a reasonable opening and then start hallucinating moves, because they were trained on language, not calculation.
• 12:49
  So the team split the job into pieces, and the split is the lesson.
• 12:53
  First, they run the full game through Stockfish — the classical chess engine — which gives them ground truth on the best move.
• 13:00
  Then they run a battery of detectors over each position, picking out the forks and pins and skewers and the structural facts like doubled pawns.
• 13:09
  Then they add a third engine called Maia, a research project out of the University of Toronto, which doesn't predict the best move — it predicts the move a human at a given rating would actually play.
• 13:20
  That's how the system can say not just 'this was the right move' but 'this was the right move, and it was hard to find at your level.'
• 13:35
  And here's the constraint, in Asbjørn's words: 'the LLM's job is only to translate this information into English, because we really don't want it to try to figure out too much on its own, because it quickly leads to hallucination.' The model is a translator.
• 13:50
  Every claim it makes is grounded in something a real engine computed.
• 13:54
  It's explicitly not allowed to do the reasoning.
• 13:57
  The payoff is latency.
• 13:58
  Because the model isn't thinking, just phrasing, they hit it with Gemini 3 Flash and get end-to-end responses in about three seconds — fast enough that a player flipping through their game never sees a spinner.
• 14:11
  They keep sixteen evaluation scenarios around tactics, blunders, and hallucination.
• 14:15
  Outputs get judged with a model-as-judge setup, and everything runs through OpenRouter so they can swap models as new ones land.
• 14:23
  Gemini Flash clears about seventy-five percent of their scenarios.
• 14:27
  Claude on higher thinking effort actually scores lower, around sixty, and is much slower — which, for a translation job, is the result you'd expect.
• 14:35
  There's a second half to the talk.
• 14:37
  When a user flags a piece of commentary as bad, that report gets injected — through a Model Context Protocol server — into a running Claude Code session.
• 14:46
  The session picks up a triage skill, investigates what the detectors got wrong, and modifies a prompt or writes a new detector.
• 14:53
  Then it regenerates the commentary, checks its own work, and messages the engineer on Slack to ask whether the fix looks right.
• 15:01
  Asbjørn described approving one of these from his phone on a bus, and merging the pull request from mobile.
• 15:07
  The whole thing is a good answer to a question a lot of teams get wrong.
• 15:11
  The reflex is to ask the model to be smart.
• 15:13
  The Play Magnus build asks it to be precise about something else's intelligence, and saves the smartness for an offline loop where a wrong answer costs a code review, not a user.
• 15:24
  If you're putting a model in front of users at low latency, ask which part of the job is actually calculation — and then hand that part to something that calculates.
• 15:33
  We've talked about Mythos here before — Anthropic's offensive-security model — so consider this an update rather than a re-introduction.
• 15:42
  The UK's AI Security Institute published a blog post this week called 'How fast is autonomous AI cyber capability advancing?', and two findings stood out.
• 15:51
  The first is a number.
• 15:52
  The Institute now estimates that the length of cyber task a frontier model can complete autonomously is doubling roughly every four to five months.
• 16:01
  That's an acceleration — their previous estimate was every eight months — and they note that the latest models, Claude Mythos Preview and GPT-5.5, substantially exceeded even the faster trend line.
• 16:14
  On their two internal cyber ranges, a newer Mythos checkpoint solved the first, called 'The Last Ones,' in six of ten attempts, and solved the second, 'Cooling Tower,' in three of ten — the first time any model has finished that second range at all.
• 16:29
  GPT-5.5 solved the first range three times in ten and didn't finish the second.
• 16:34
  The second finding is methodological, and it's the one I'd flag harder.
• 16:38
  The Institute caps each task at two and a half million tokens.
• 16:42
  Not because that's realistic — because, in their words, without the cap, 'success rates are so high that time horizons become impossible to calculate.' Their measurement instrument saturates.
• 16:54
  They're deliberately handicapping the model with a stripped-down harness and a token budget so they can still get a number out the other end.
• 17:02
  When a benchmark's main design constraint is making the model do worse so the ruler still works, that tells you something about where the capability already is.
• 17:12
  The Reddit discussion surfaced a third detail.
• 17:15
  One commenter pointed out — citing Anthropic's Logan Graham — that the checkpoint the Institute tested appears to be the one already deployed under Anthropic's Project Glasswing.
• 17:26
  If that's right, the safety evaluation is running behind the deployment: by the time a checkpoint clears review, the next one is already in front of users.
• 17:35
  I can't fully confirm that timing from primary sources, so take it as a thread to watch, not a settled fact.
• 17:42
  What I'd hold onto is the gap between two clocks.
• 17:45
  The capability clock is task length, and it's doubling every few months.
• 17:49
  The evaluation clock is slower — slow enough that the institutions measuring it are capping their own tests to keep the math tractable.
• 17:58
  The post is careful about what it doesn't know: how the pace evolves from here, when any particular threshold gets crossed, and how any of this performs against a system someone is actively defending, which is a very different problem than a cyber range.
• 18:13
  So the headline isn't the six-out-of-ten.
• 18:16
  It's that the people whose job is to measure this are telling you, in print, that their instruments are starting to max out.
• 18:23
  A post on the LocalLLaMA subreddit this week put two changes side by side that I'd been tracking separately, and together they sketch a real problem for anyone building agents that touch the open web.
• 18:35
  Change one: Google is ending free full-web search through its Programmable Search Engine — the thing formerly called Custom Search.
• 18:43
  The free tier is being capped at fifty domains.
• 18:46
  If you want to search the actual web, that becomes a paid product, and existing full-web search engines have to migrate off by January first, 2027.
• 18:55
  The pricing for the paid full-web option isn't public yet; you fill out an interest form.
• 19:00
  Bing has been tightening its search API on a similar timeline.
• 19:04
  Change two: Cloudflare.
• 19:05
  Their default posture now is to challenge AI bots trying to scrape pages, across their customer base — and that footprint is large and getting larger.
• 19:14
  So the supply of cheap programmatic search is shrinking from one direction while the cost of just fetching pages yourself goes up from the other.
• 19:23
  The original poster described harnesses that used to fetch pages now coming back with four-hundred-level errors from site after site.
• 19:31
  That's the Cloudflare side showing up in practice.
• 19:34
  The poster framed this as Google 'pulling up the drawbridge,' and I think the diagnosis underneath that is roughly right, even if the language runs hot.
• 19:43
  A commenter named JockY put it more plainly: search providers are seeing a flood of bot queries with no human eyes attached, which means no ad revenue attached, and they're realizing an unmonetized firehose is a cost they can simply turn off.
• 19:58
  The economics of web search were always 'humans look at ads.' Agents don't look at ads.
• 20:03
  So the thing that was effectively free — because you were the product — gets repriced once the traffic isn't a person.
• 20:10
  For builders, this is concrete.
• 20:12
  If you've got a retrieval-augmented generation pipeline, or an agent that does research, and it leans on a cheap or free search API plus the ability to fetch arbitrary pages, both of those legs are getting more expensive and less reliable over the next year.
• 20:27
  Better to know that now, while you can design around it, than to discover it when a provider deprecates out from under you.
• 20:35
  The thread also surfaced the obvious counter-move — decentralized, open search indexes.
• 20:40
  Someone pointed to YaCy, a peer-to-peer open-source search engine that's been around for about twenty years and never quite had its moment.
• 20:48
  Whether YaCy specifically is the answer, I'm skeptical.
• 20:52
  But the poster's instinct seems sound: a properly open, agent-usable search index is a gap, and a gap that big tends to get filled.
• 21:00
  I don't know who fills it.
• 21:01
  I'd just plan your retrieval layer over the next year as if the free option is going away — because the announced changes say it is.
• 21:09
  Quick one for the local-model crowd, and it comes with a built-in argument, which is the best kind.
• 21:15
  A developer posting as gladkos shared a patched build of llama.cpp — the C++ inference engine that runs models on your own hardware — with multi-token prediction added for Qwen models.
• 21:27
  Multi-token prediction is a speedup technique: instead of generating one token at a time, the model proposes several at once, and a verification step accepts the ones that hold up.
• 21:38
  The numbers posted, on a MacBook Pro M5 Max: a Qwen 3.6 model at twenty-seven billion parameters going from twenty-one tokens per second to thirty-four.
• 21:47
  That's the plus-forty-percent in the headline, with a reported ninety percent acceptance rate on the speculated tokens.
• 21:55
  There's more here than one benchmark.
• 21:57
  The local-model story for the last year has been less about new weights and more about squeezing the hardware you already own — quantization, speculative decoding, and now multi-token prediction showing up outside the big managed runtimes.
• 22:12
  Each technique is a few percent to a few tens of percent, and they stack.
• 22:16
  A twenty-seven-billion-parameter model at thirty-four tokens a second on a laptop is a usable coding assistant, fully offline.
• 22:24
  That throughput is what the gain actually buys.
• 22:27
  But the post bundled multi-token prediction with a second thing called TurboQuant, a quantization method, and that's where the comment section pushed back hard.
• 22:37
  One commenter asked flatly why people keep posting TurboQuant results as if it's faster, when in his testing it's slower than the standard sixteen-bit and four-bit builds.
• 22:48
  Another reply added the useful detail: there was a TurboQuant pull request to llama.cpp proper, and it got rejected — the maintainers found it didn't beat the existing four-bit rotation work, and was only arguably useful at the most aggressive quantization, where quality already suffers.
• 23:06
  So it's a split decision.
• 23:07
  Multi-token prediction landing in a llama.cpp build for Qwen is one to grab if you run local — that's a third more throughput on the same machine.
• 23:16
  The TurboQuant claim around it is contested by people who've looked closely, and the project maintainers already said no once.
• 23:24
  I'm flagging both halves because the post presents them as one result, and they are not one result.
• 23:30
  This is the normal texture of the local scene — fast, generous sharing, and a comment section that does the peer review in public.
• 23:38
  Read the replies before you flash anything.
• 23:41
  I'll end somewhere lighter, but it connects.
• 23:44
  This week an artist posted a real Monet painting and labelled it AI-generated, just to see what would happen.
• 23:50
  What happened, predictably, is that people lined up to call it slop — soft and mushy, obviously fake, and no real brushwork.
• 23:58
  It was a Monet.
• 23:59
  The account behind it, SHL0MS, ran it as a straight social experiment, and Jediwolf, who reshared it, called it 'the coolest art social experiment I've seen in a while.' Marc Andreessen replied to the original with a single stunned-face emoji.
• 24:14
  The sharpest comment came from Cristóbal Valenzuela, who runs Runway — a company whose entire business is AI-generated video, so he has standing here.
• 24:23
  His note: 'Monet was probably one of the biggest slop painters of his era and, by all means, managed to help transform the entire art world.' And that's just true.
• 24:33
  Impressionism was a label of contempt when it was coined.
• 24:36
  The thing we now hang in temperature-controlled rooms was, in its moment, the soft mushy stuff that didn't look like real painting.
• 24:44
  I'm not going to stretch this into a defense of AI image slop, because most AI image slop is, in fact, slop.
• 24:51
  But the experiment isolates something about how we're all judging this stuff right now.
• 24:56
  A lot of the 'this is AI' reaction is not actually a read on the pixels.
• 25:01
  It's a read on the label, and then the eyes go looking for confirmation.
• 25:05
  We've trained ourselves, in about three years, to find a tell — and the Monet test shows the tell-detector fires false positives, confidently, in public.
• 25:14
  For anyone building with generative tools, that cuts both ways.
• 25:18
  The reflexive contempt will sometimes land on your good work for no better reason than a suspicion of how it was made.
• 25:25
  And the reflexive amazement will sometimes wave through bad work because it came wrapped in the right process story.
• 25:33
  The only thing that survives both reflexes is the same thing that survived them in Monet's day — actually looking at the work, and having taste.
• 25:41
  That part didn't get automated.
• 25:43
  That's it for today.
• 25:44
  June fifteenth is the date I've got circled — that's when Anthropic's Agent SDK metering goes live, and a lot of people are going to learn what their agent loops actually cost.
• 25:55
  — Lenar Kess.