Three teams gave up a deep integration today and took a contract instead
Serguey Asael Shinder3 min readAngular, Microsoft and Cloudflare published unrelated things this evening, and each one is the same trade: a team that had built deeply into another system stepped back to a narrower, documented boundary — and in every case the reason was that the deep version could not survive a change it did not control.
Angular states it outright. Its ahead-of-time compiler was built on the TypeScript compiler's APIs, it performs its own transformations through ts.Transformer, and that API does not exist across a language boundary — so the integration cannot follow TypeScript into a Go implementation. The replacement, the Angular Preprocessor, does not try. It consumes components and templates and emits ordinary TypeScript for somebody else to type-check, two output files per input file, with oxc doing the transformation. Angular moves from being part of the type checker to producing input for it. The capability it gives up is the ability to reach inside; the capability it buys is the ability to be present when the host is rewritten.
Microsoft's AG-UI announcement is the same move from the other direction. The .NET SDK is not the story — the line that matters is that the Microsoft Agent Framework's own AG-UI support is now based on that SDK rather than being a parallel implementation maintained beside it. A vendor with a private implementation can track a spec loosely and absorb the drift internally. A vendor that consumes the shared packages cannot: a defect in AGUI.Abstractions is now a defect in the product. The boundary got narrower and harder, and that is the point.
Cloudflare's Turnstile Spin looks like a convenience feature and rests on the same observation. Turnstile's two-step shape — widget in the frontend, Siteverify call in the backend — assumed a single person writing both halves. When that assumption stopped holding, the integration started failing in a specific way: the visible half installed, the deciding half absent. The tell is the "Fix with Spin" button, which can only be offered because Cloudflare can see widgets issuing tokens while no verification calls arrive. The response is not to make the two-step flow easier to follow but to stop requiring anyone to follow it.
What connects the three is not native code, or agents, or Rust. It is that a deep integration is a bet on the other side holding still. Angular's bet ran out when TypeScript changed language. Turnstile's ran out when the population of people installing it changed. Microsoft's was voluntary, which is the interesting case: nothing forced it, and giving up the private implementation removed the option of quietly diverging.
The practical reading, if you maintain something that hooks into another system's internals: the question is not whether your integration works, but what change on the other side would end it, and whether you would find out from a release note or from your own build. Angular knew — the post says the team understood the deep integration could not work with a Go-compiled TypeScript, and planning started early this year rather than after the stable release landed. That is the part worth copying.