Latest / Braid / The Trust Tax

Transcript

The Trust Tax · Braid

• 0:04
  Yesterday afternoon, Anthropic ran what might be the most poorly executed A/B test in AI platform history.
• 0:11
  They tried to remove Claude Code from their twenty-dollar Pro tier — but only for two percent of new signups.
• 0:18
  The problem?
• 0:19
  They updated the pricing page for everyone.
• 0:22
  Simon Willison caught it in real-time.
• 0:25
  Quote — "Wrote up Anthropic's self-own about Claude Code pricing from this afternoon on my blog - it turned out they'd reversed course just as I hit publish." End quote.
• 0:36
  Here's what actually happened, according to the one Anthropic employee who bothered to explain.
• 0:43
  They were testing whether new users would pay a hundred dollars for Claude Code access instead of twenty.
• 0:50
  Fair enough — that's what A/B tests are for.
• 0:53
  But someone pushed the documentation changes to production for all users, not just the test group.
• 1:00
  Existing Pro subscribers saw Claude Code disappear from their tier listing.
• 1:05
  New users trying to sign up saw conflicting information.
• 1:09
  The community went ballistic.
• 1:11
  Gergely Orosz called it a fake door test — the kind where you advertise something that doesn't exist to gauge interest.
• 1:19
  Except Anthropic did it backwards.
• 1:21
  They removed something that did exist to see who would complain.
• 1:25
  The reversal came within hours.
• 1:28
  The checkbox for Claude Code reappeared on the Pro tier.
• 1:31
  No announcement.
• 1:32
  No explanation.
• 1:33
  Just a silent flip back, as if nothing happened.
• 1:37
  The only official communication?
• 1:39
  That single tweet from an employee saying the test was still running for those two percent.
• 1:45
  The timing couldn't be worse.
• 1:47
  This is the same week Anthropic had to limit Claude usage because they're compute-constrained.
• 1:54
  The same week they pulled OAuth access from third-party tools like pi.
• 1:58
  The same week OpenAI's Sam Altman is literally drunk-tweeting about giving users more compute.
• 2:05
  The real tell here isn't the price test.
• 2:08
  Companies test pricing all the time.
• 2:10
  It's the execution — updating public documentation for an experiment affecting two percent of users suggests either remarkable sloppiness or genuine confusion about their own product strategy.
• 2:23
  And the silence afterward?
• 2:25
  That's the trust tax.
• 2:26
  When you change pricing without announcement, revert without explanation, and leave your community to figure out what happened from scattered tweets, you're telling developers something important: you're not ready for them to build on you.
• 2:43
  Mario Zechner put it best: "clampy clampy clampdown.
• 2:46
  just waiting for OAI to clamp down as well." The platforms are all compute-constrained.
• 2:52
  The difference is who admits it and who pretends otherwise.
• 2:56
  While Anthropic was fumbling their pricing, Mozilla was dealing with a different kind of Anthropic problem: Mythos found too many bugs.
• 3:05
  Two hundred and seventy-one vulnerabilities in Firefox, all discovered using early access to Anthropic's Mythos Preview.
• 3:13
  That's not a typo.
• 3:14
  Mozilla's Firefox 150 release this week patches all of them.
• 3:18
  Bobby Holley, Firefox's CTO, frames this as a turning point.
• 3:22
  Quote — "Our belief is that the tools have changed things dramatically, because now we have automated techniques that can cover, as far as we can tell, the full space of vulnerability-inducing bugs." End quote.
• 3:36
  Think about what that means.
• 3:38
  For decades, finding vulnerabilities required either automated fuzzing that missed entire categories of bugs, or expensive human analysis that couldn't scale.
• 3:48
  Attackers and defenders played the same game with the same tools.
• 3:53
  The economics kept most software relatively safe — not because it was secure, but because finding the bugs was expensive.
• 4:00
  Mythos breaks that equilibrium.
• 4:03
  Holley again: "Every piece of software is going to have to make this transition, because every piece of software has a lot of bugs buried underneath the surface that are now discoverable."
• 4:18
  Every codebase will go through it.
• 4:20
  The question is whether you do it now, with early access to defensive tools, or later, when attackers have them too.
• 4:28
  Here's the part that should terrify open source maintainers: Holley says he's talked to engineering leaders at large companies who are pulling thousands of engineers off everything else to work on this for six months.
• 4:42
  Mozilla had the resources and the early access to handle their 271 bugs.
• 4:47
  What about the Node package with two maintainers?
• 4:50
  What about abandonware that still runs in production?
• 4:54
  Raffi Krikorian, Mozilla's CTO, published an op-ed in the Times last week that cuts to the economics: "The most valuable software infrastructure in the world continues to be maintained by people working for free, while the companies building fortunes on top of it never had to pay for its upkeep."
• 5:18
  The companies with early access to Mythos, like Mozilla, will patch their code.
• 5:24
  The Fortune 500 will mobilize their thousands of engineers.
• 5:27
  But the open source libraries they all depend on?
• 5:31
  Those maintainers are about to get buried under an avalanche of CVEs with no resources to fix them.
• 5:37
  Holley thinks this is a finite transition.
• 5:40
  Once we've found and fixed the discoverable bugs, the playing field levels again.
• 5:45
  Maybe.
• 5:46
  But between now and then, we're looking at a massive transfer of security debt from latent to active.
• 5:53
  Every bug that's been sitting dormant for years is about to become visible.
• 5:58
  And here's the kicker: Mythos isn't even publicly available yet.
• 6:02
  This is just the preview, with a handful of partners.
• 6:05
  When the real version ships — or when competitors catch up — this bootcamp becomes mandatory for everyone.
• 6:12
  Saturday night, 9:28 PM Pacific.
• 6:14
  Sam Altman tweets: "tongiht i have had a couple of drinks."
• 6:42
  The contrast isn't subtle.
• 6:43
  While Anthropic silently removes features and tests five-x price increases, Sam's playing the generous drunk uncle who wants everyone to have seconds.
• 6:55
  Except he's not that drunk.
• 6:57
  Later in the thread, he's coherent enough to make strategic product announcements.
• 7:03
  The typos are performative.
• 7:05
  The message is calculated: OpenAI has compute to burn.
• 7:09
  Jason Liu captured the technical undercurrent: "Heard mythos got leaked.
• 7:14
  Would love give the team codex security it's generally available for anyone with a pro plan!
• 7:21
  No research preview.
• 7:22
  No waitlist."
• 7:37
  The Mythos preview that found Mozilla's 271 bugs?
• 7:40
  That kind of capability is already in ChatGPT if you know how to prompt it.
• 7:46
  Meanwhile, VictorTaelin posted: "actually quite depressed about the mythos stuff.
• 7:52
  grinding my way through, I'll do it with or without them." Eleven hundred likes.
• 7:58
  The developer who was counting on Anthropic's promises is giving up and moving on.
• 8:04
  Sam's response?
• 8:05
  "come to the light side." Four thousand likes.
• 8:08
  This is resource competition performed as platform theater.
• 8:13
  OpenAI's message is clear: we're not compute-constrained, we're not pulling features, we're not testing 5x price increases.
• 8:22
  We're so abundant we can afford to have our CEO drunk-tweet about giving away more compute.
• 8:29
  Whether it's true is almost beside the point.
• 8:32
  Perception is reality in platform wars.
• 8:35
  Developers go where they feel welcome, where the resources are stable, where the CEO tweets about giving you more, not taking things away.
• 8:45
  The irony is that Jeremy Howard confirmed something important in the chaos: the Codex endpoints that power pi and OpenCode are officially supported.
• 8:56
  OpenAI staffer validated it.
• 8:58
  After months of developers wondering if they were building on unofficial APIs, turns out OpenAI was fine with it all along.
• 9:07
  They just never bothered to document it.
• 9:10
  That's the difference in platform philosophy.
• 9:14
  Anthropic documents everything, announces changes, runs careful tests — then breaks trust with execution.
• 9:22
  OpenAI runs fast and loose, barely documents anything, has their CEO tweet drunk — but keeps the compute flowing.
• 9:30
  Guess which one developers are choosing.
• 9:33
  While the labs fight over compute scarcity, Google just announced they're done with general-purpose AI chips.
• 9:41
  Two new TPUs, both eighth generation, but built for completely different jobs.
• 9:46
  The TPU 8t for training — scales to 9,600 chips in a single superpod, two petabytes of shared memory, 121 exaflops of compute.
• 9:56
  The TPU 8i for inference — 288 gigs of high-bandwidth memory, 384 megs of on-chip SRAM, designed to keep models entirely in cache.
• 10:05
  The split is the announcement.
• 10:07
  Google's betting that training and inference are becoming fundamentally different workloads.
• 10:14
  Training wants massive compute and scale-up bandwidth.
• 10:18
  Inference wants memory bandwidth and minimal latency.
• 10:22
  You can't optimize for both, so they're not trying.
• 10:25
  The TPU 8i specifically targets what Google calls "swarming" — many specialized agents working together in complex flows.
• 10:34
  They've rebuilt the stack to eliminate what they call the waiting room effect.
• 10:40
  Triple the on-chip SRAM from last generation.
• 10:43
  Double the physical CPU hosts per server.
• 10:46
  New interconnect architecture that cuts network diameter by half.
• 10:51
  But here's the number that matters: ninety-seven percent goodput.
• 10:56
  That's useful, productive compute time.
• 10:58
  At frontier training scale, every percentage point of downtime translates to days of lost training.
• 11:06
  Google's building for a world where hardware failures get routed around automatically, where optical switches reconfigure networks without human intervention, where ten thousand chips act as a single logical unit.
• 11:21
  This is infrastructure for the agent era that Google sees coming.
• 11:26
  Not one model doing everything, but swarms of specialized agents that need different hardware for training versus deployment.
• 11:35
  The TPU 8t builds them.
• 11:37
  The TPU 8i runs them.
• 11:38
  The timing is intentional.
• 11:40
  Google's been watching OpenAI and Anthropic fight over scarce compute, watching developers complain about rate limits and price increases.
• 11:50
  Their response?
• 11:51
  Build more silicon.
• 11:53
  Different silicon.
• 11:54
  Silicon designed for the actual workloads instead of forcing everything through the same architecture.
• 12:01
  Citadel Securities is already on board.
• 12:04
  When a high-frequency trading firm chooses your AI infrastructure, that's a signal about latency and reliability.
• 12:12
  These aren't research projects.
• 12:15
  This is production infrastructure for companies that measure downtime in millions per minute.
• 12:21
  The message to developers is clear: while OpenAI and Anthropic ration compute, Google's building the infrastructure for abundance.
• 12:31
  Not promising it.
• 12:32
  Building it.
• 12:33
  In silicon.
• 12:34
  The Vercel breach last week keeps getting worse the more we learn.
• 12:38
  Initial reports said customer environment variables were exposed.
• 12:43
  True.
• 12:44
  But the how matters more than the what.
• 12:47
  It started with a Context.ai employee downloading Roblox game exploits in February.
• 12:52
  Lumma Stealer malware infected their machine, stole their credentials, gave attackers access to Context.ai's AWS environment.
• 13:01
  From there, the attackers grabbed OAuth tokens for Context AI Office Suite users — including a Vercel employee.
• 13:09
  Think about that chain.
• 13:11
  A gaming download leads to stolen OAuth tokens leads to compromised Google Workspace leads to Vercel's internal systems.
• 13:19
  No passwords cracked.
• 13:21
  No systems hacked.
• 13:22
  Just OAuth tokens doing what they're designed to do — maintaining persistent access that survives password rotations.
• 13:30
  Guillermo Rauch, Vercel's CEO, said something revealing about the attacker's speed: he attributed it to AI augmentation.
• 13:39
  This wasn't a sophisticated zero-day.
• 13:41
  It was standard techniques executed faster than defenders expected.
• 13:46
  Two-month dwell time.
• 13:48
  That's how long the attackers had access before disclosure.
• 13:52
  In the old world, two months was nothing — attackers might spend that long just mapping the network.
• 13:59
  In the AI-accelerated world, two months is enough to enumerate, extract, and monetize.
• 14:05
  Here's what should scare platform teams: Vercel's design marked some environment variables as sensitive and encrypted them.
• 14:14
  The rest were readable with internal access.
• 14:17
  That classification decision — what's sensitive versus what's not — became the blast radius of the breach.
• 14:24
  The problem isn't OAuth.
• 14:26
  The problem isn't environment variables.
• 14:29
  The problem is trust chains.
• 14:31
  Every OAuth grant creates a trust relationship.
• 14:34
  Context.ai trusted an employee's machine.
• 14:37
  Vercel trusted Context.ai's OAuth app.
• 14:40
  Vercel's customers trusted Vercel's classification of sensitive versus non-sensitive.
• 14:46
  Each link made sense in isolation.
• 14:48
  The chain was the vulnerability.
• 14:51
  This is the same week Anthropic pulled OAuth access from third-party tools.
• 14:56
  The same week GitHub added telemetry to their CLI.
• 14:59
  The same week everyone's tightening access controls.
• 15:03
  They're all seeing the same thing: the trust model is broken.
• 15:07
  When an AI-augmented attacker can traverse from a gaming download to production environment variables in weeks, when OAuth tokens become lateral movement highways, when platform providers can't protect customer secrets from their own third-party integrations — that's not a breach.
• 15:27
  That's a rearchitecture forcing function.
• 15:30
  The Vercel incident won't be the last OAuth chain attack.
• 15:34
  It might not even be the worst.
• 15:37
  But it's the one that made everyone realize: in the AI-accelerated world, trust isn't transitive anymore.
• 15:44
  Step back.
• 15:44
  Look at the pattern.
• 15:46
  Anthropic can't share compute, so they're testing 5x price increases.
• 15:51
  OpenAI has compute but won't document their APIs.
• 15:54
  Google's building new silicon but it won't ship until year-end.
• 15:59
  Mozilla found 271 bugs they wouldn't have looked for.
• 16:03
  Vercel's OAuth chain broke in ways they didn't model.
• 16:06
  Every one of these is a resource allocation problem dressed up as a technical issue.
• 16:12
  Anthropic has the models but not the compute.
• 16:16
  OpenAI has the compute but not the discipline.
• 16:19
  Google has the roadmap but not the timeline.
• 16:22
  Open source has the vulnerabilities but not the maintainers.
• 16:27
  Platforms have the integration points but not the trust model.
• 16:31
  And in the middle of all this: builders trying to ship products.
• 16:36
  Mario Zechner's pi harness works around Anthropic's OAuth restrictions — until Anthropic breaks the workaround.
• 16:44
  Jeremy Howard celebrates Codex being officially supported — a day before GitHub pauses new Copilot signups entirely.
• 16:52
  Developers build on Claude Code at twenty dollars — then wake up to find it might cost a hundred.
• 16:59
  The infrastructure is shifting faster than the applications.
• 17:03
  That's backwards.
• 17:05
  Infrastructure is supposed to be boring, stable, reliable.
• 17:09
  The thing you build on, not the thing you worry about.
• 17:13
  But here we are.
• 17:14
  The models are thinking now, literally spending compute cycles to reason through problems.
• 17:20
  The hardware is splitting into specialized architectures.
• 17:24
  The security model is inverting from "find some bugs" to "all bugs are findable." The platforms are testing prices in production.
• 17:34
  Bobby Holley called it a finite transition.
• 17:37
  Once every codebase goes through its Mythos bootcamp, once the TPU 8s ship, once the pricing models stabilize, we'll reach a new equilibrium.
• 17:47
  Maybe.
• 17:48
  Or maybe this is the new normal.
• 17:50
  Platforms iterating in public.
• 17:52
  Security vulnerabilities arriving in avalanches.
• 17:56
  Compute resources appearing and disappearing based on CEO mood.
• 18:00
  Trust chains breaking weekly.
• 18:02
  The builders who survive will be the ones who treat instability as a design constraint.
• 18:09
  Multiple model providers.
• 18:10
  Local fallbacks.
• 18:12
  Defensive coding against platform changes.
• 18:15
  Architecture that assumes OAuth will break, APIs will change, prices will 5x overnight.
• 18:21
  That's not cynical.
• 18:22
  That's what we're seeing.
• 18:24
  Every incident this week — Anthropic's pricing test, Mozilla's bug avalanche, Sam's drunk tweets, Vercel's breach — they're all symptoms of the same thing: the old stability is gone, and the new stability hasn't arrived.
• 18:40
  We're in the transition.
• 18:42
  Build accordingly.
• 18:43
  — Lenar.