Seroter's Daily Reading — #799 (June 5, 2026) — Seroter's Daily Reading

Listen: https://blossom.nostr.xyz/32edf6a1c18d1ac4d481929467b0beed067d0d15ebc5b9acc602441db118ab7f.mpga

Seroter's Daily Reading, episode 799. June 5, 2026.

Let's ease into this one. Announcing Angular v22 dropped, and it's one of those releases where you look at the changelog and think, wow, they moved a lot of pieces at once. Three features hit stable: Signal Forms, Angular Aria, and the Asynchronous Reactivity APIs including resource and httpResource. Signal Forms is the new reactive, composable, typed forms API that Angular's been building toward for a couple versions now. Angular Aria is a set of twelve accessibility patterns — accordion, combobox, those kinds of components — that handle the a11y complexity so you don't have to. And resource and httpResource bring asynchronous signals to Angular, which sounds like a small thing until you try to do real async data fetching with pure signals and realize you need this.

But what I found more interesting is the agentic angle. Angular has been building out angular.dev/ai, and v22 pushes hard in that direction. They've updated their MCP server — that's Model Context Protocol for anyone living under a rock — to include a devserver.wait_for_build tool that lets coding agents build your app, read the output, and self-correct without human intervention. That's a real self-healing loop. They also shipped Angular Agent Skills on GitHub, which are essentially a standardized way to give AI coding assistants immediate context on modern Angular patterns like Signal Forms and Angular Aria. The file itself is under 140 lines, pulling in deep reference content only when the agent needs it — progressive disclosure for AI, basically. And there's experimental WebMCP support, which is Chrome's emerging protocol for letting web apps expose structured tools directly to agents. So Angular isn't just keeping up with the agentic era, it's actively shaping what that looks like.

Moving to something completely different. Google released Gemma 4 12B, and it's a dense multimodal model that punches well above its weight class for its size. The headline is that it runs locally on a GPU laptop with 16 gigs of VRAM, which used to be the exclusive domain of tiny edge models. But the architecture is what caught my eye. Gemma 4 12B uses an encoder-free design for text, image, and audio. It skips the separate frozen vision and audio encoders that traditional multimodal models use, feeding raw inputs directly into the LLM. That reduces latency and lets you fine-tune everything in a single pass, which is a meaningful advantage for local fine-tuning workflows. Google also released native MacOS desktop apps, an OpenAI-compatible local API server via a new CLI tool, and a Gemma Skills repository for agents. Local, privacy-preserving AI just keeps getting more viable.

If you're a .NET developer, or even if you're just curious about how a major platform survives a decade of identity crises, there's a really well-written retrospective on The Many Deaths and Rebirths of .NET over at Binary Intellect. The piece traces the full arc from .NET Framework 1.0 in 2002 — which assumed Windows was the only platform that would ever matter — through the quiet revolution of .NET Core in 2016, the awkward peace of .NET Standard, and the unification of .NET 5 in 2020 when Microsoft finally dropped the "Core" qualifier and just called it .NET. What makes the piece compelling isn't the technical details — you can find those anywhere — it's the philosophy underneath. The argument is that .NET Framework succeeded so completely within its assumed world that it couldn't see the edges of that world until the world had already moved. The deep Windows integration that made it powerful also made it immovable. And what saved the platform wasn't a clever technical decision. It was an act of institutional humility: Microsoft open-sourcing .NET Core on GitHub and saying come help us build this. The piece puts it well — you cannot fake that kind of credibility. It has to be built through action over years. The lesson for everyone, not just .NET folks, is that platforms, like people, grow by being willing to outgrow themselves. The hardest part is not learning the new APIs. The hardest part is letting go of the version of yourself that was expert in the old ones.

Here is something from the world of finance that cuts through the usual AI hype for a second. Wells Fargo CEO Charlie Scharf spoke at a Bernstein investor conference this week, and he said something that should probably be quoted more often. He said he finds it surprising when really smart people take one side or the other on whether AI threatens employment. They either say it's not a threat or they say it's a huge threat. And Scharf's response is: looking at the way Wells Fargo is using AI inside the company, it is both of those things at the same time. The risk, he says, is that the people being displaced by AI and the people getting new opportunities from AI are not the same people, and the timing doesn't line up either. Scharf is also worth listening to here because his perspective isn't naive — he's been dealing with massive regulatory overhead and forced spending at Wells Fargo since the 2016 fake-accounts scandal, and the bank has cut roughly 70,000 jobs under his tenure while investing heavily in efficiency. He explicitly says people don't go away, but there's a mismatch that as a country we're going to have to deal with through retraining and careful planning. He's not catastrophizing, but he's also not sugarcoating it. It's a useful counterweight to the乐观 and悲观 camps.

RedMonk's Steve O'Grady published a fascinating piece this week on what Anthropic's acquisition of Bun tells us about AI, open source, and what big AI companies actually value. For the uninitiated, Bun is the fast JavaScript runtime, package manager, and bundler that was acquired by Anthropic in December. It's MIT licensed, and the acquisition announcement made four promises: stays open source, actively maintained, same team, built on GitHub. O'Grady's data shows that three of those four are holding up well. Bun is growing — npm installs are up 16X in less than 30 months. It remains MIT licensed and actively built on GitHub. But the team has largely dispersed. At least four of the original Oven committers have left or stopped contributing. And here's the striking part: over 80% of commits post-acquisition are coming from bots, not humans. Jarred Sumner has acknowledged this publicly, saying they haven't been typing code themselves for many months. O'Grady raises the uncomfortable question that this is all happening with a project that hosts critical AI infrastructure, and there's been no move to donate it to a neutral foundation the way Anthropic eventually did with MCP. His argument is sharp: standardization isn't primarily about getting code contributions from competitors. It's about preventing market fragmentation and reassuring enterprise users who don't want key infrastructure controlled by a single vendor. The question of whether Anthropic understands open source on a corporate maturity level, he says, will be answered by how they handle Bun's stewardship. Do they trade some control for wider adoption, or do they keep it internal? We'll see.

Switching gears to something practical for the developer audience. freeCodeCamp published a thorough walkthrough on building a production REST API with Dart and Shelf — and I mean thorough. This goes well beyond hello world. It covers middleware, JWT authentication, PostgreSQL with a Docker setup, database migrations, soft deletes, partial updates, and deployment to Fly.io. What I liked about it is the framing: the gap between being a Flutter engineer and building a backend is smaller than people assume, because the concepts map directly. Models, repositories, handlers, middleware — these are the same ideas. The piece even maps handlers to ViewModels, middleware to interceptors, which is a smart way to make the unfamiliar familiar. The real difference is just understanding how Dart behaves when there's no widget tree and no BuildContext. Just a process listening on a port. Simple idea, but having it stated explicitly helps.

From David Fung over at Shift, there's a piece on why engineering leaders should be worried if their team isn't pushing back. Fung spent two decades in tech, most recently as a Senior Director at Salesforce leading Sales Engineering. His core argument is that silence from a team is misread by leaders as alignment when it often means people are either unclear on what they actually need to do, or they've simply stopped fighting because past resistance proved futile. The pattern he describes is familiar: repeated pivots train teams to stop pushing back. The solution he prescribes is counterintuitive in the current era of maximum output. Leaders, he argues, need to filter more, not generate more. Reduce the surface area of what the team has to process so they can focus. On the question of AI making this better or worse, he's blunt: worse. AI accelerates decision-making and reduces friction, which makes it harder to maintain an environment where pushback is safe. His framework for actual clarity is three parts: name what's happening, frame why it's happening, and say what it means for the people hearing it. He calls it name it, frame it, invite it. And his observation that humans were sycophantic long before AI was will either make you laugh or feel slightly uncomfortable. Possibly both.

Google Cloud published an end-to-end walkthrough on deploying their Agent Development Kit on ADK on GKE Autopilot. It covers the full pipeline: build an ADK agent with a weather tool, containerize it with a multi-stage Docker build, set up Workload Identity so the pod can call Vertex AI without managing service account keys, deploy to GKE Autopilot with horizontal pod autoscaling, and expose it via the Gateway API with a Google-managed TLS certificate. The Workload Identity setup is the part worth highlighting if you're doing GCP and Kubernetes. Instead of baking a service account key JSON file into your pod, you annotate your Kubernetes Service Account with the GCP IAM service account email, and Kubernetes handles the token exchange transparently. It's more secure and avoids the messy secret management. The whole thing is a solid reference if you're moving ADK agents from prototype to production.

Finally, and I'll keep this one short because the article itself is behind a paywall and the excerpt is limited, Harvard Business Review published a piece this week on how people are really using AI in 2026. The key message is more cautionary than the usual optimism: people are outsourcing thinking rather than just task execution, using AI for emotional support instead of human connection, and losing intentionality in their work. The argument is that we are likely going to push AI adoption too far before collectively pulling back to a better balance. It's a useful corrective to the narrative that more AI is always better, and a reminder that the human dimensions of work and decision-making don't disappear just because the tooling gets faster.

That's episode 799. A few threads worth noting across today's set: there's a strong theme around platform evolution and identity — .NET's decades-long reinvention, Anthropic's stewardship of Bun, Angular's agentic pivot. There's also a consistent thread on AI's real-world limits and complications — Wells Fargo's nuanced view of employment, the HBR piece on how we're actually using AI, and even the engineering leadership piece on why friction and pushback matter. And for the practitioners, there's plenty of actionable content: the Dart Shelf tutorial, the ADK on GKE walkthrough, and the Gemma 4 12B guide for anyone experimenting with local models. See you Monday.

Announcing Angular v22 — Angular Blog
Gemma 4 12B: The Developer Guide — Google Developers Blog
The token bill comes due: Inside the industry scramble to manage AI's runaway costs — TechCrunch
The Many Deaths and Rebirths of .NET — Binary Intellect
Wells Fargo CEO: AI's effect on employment is 'complicated' — Banking Dive
Migrating to Antigravity CLI — Google Cloud (Medium)
What Bun Can Tell Us About AI, Open Source and Anthropic — RedMonk
From Flutter to Backend: How to Build and Ship Production REST APIs with Dart and Shelf — freeCodeCamp
Hybrid AI in Flutter: Routing Between On-Device and Cloud Models — Medium
Build your own Flutter GenUI solution with Gemini structured outputs — Medium
Engineering Leaders, You Should Be Worried If Your Team Isn't Pushing Back — Shift
Scaling AI Agents: A Step-by-Step Guide to Deploying ADK on GKE Autopilot — Google Cloud Blog
How People Are Really Using AI in 2026 — Harvard Business Review