Svelte 5, AI Code Verification, and the React.FC Debate

TL;DR

Svelte 5 released 50+ free animation components
Treating AI agent output like compiler output is gaining traction
Gusto removed React.FC from 5,000+ files and found hidden bugs
Browser-based language models: promise and concerns
ml-sharp-web brings Apple's Gaussian Splats to the browser

Svelte 5 Animations: 50+ Free Components

Svelte continues to push the boundaries of what's possible with reactive frameworks. The new Svelte 5 animations library gives developers a massive collection of ready-to-use animation components built with TypeScript, Tailwind CSS, and Motion SV.

What stands out here is the practical focus. These aren't showy animations designed to impress in a demo — they're the kinds of transitions and micro-interactions that actually make interfaces feel polished. Fade-ins, slide transitions, spring physics, staggered reveals. The stuff you normally either skip because it's too much work or roll yourself badly.

The fact that it's all free and open-source makes this even better for teams building production apps. You get professional-grade animations without the licensing headaches or the "build it yourself and hope it's decent" approach.

Svelte 5 Animations

Treating AI Agent Output Like Compiler Output

This one hit close to home. The argument goes: the problem with AI-generated code isn't that it's AI-generated — it's that we don't have the verification infrastructure to trust it properly.

Think about how we trust compilers. We don't blindly believe the binary is correct. We have type systems, test suites, monitoring, rollback mechanisms. There's an entire ecosystem of trust built around compiled code. The same infrastructure doesn't exist for AI-generated code.

The author frames "lights-out codebases" (codebases entirely written by AI) not as something to fear, but as a design target. That reframing matters. We're not trying to stop AI from writing code — we're trying to build the safety nets that make AI-written code as trustworthy as compiler output.

Key pieces needed: formal specifications, AI-checks-AI pipelines, and production instrumentation. This is the infrastructure engineering work that will define the next decade of software development.

Treat Agent Output Like Compiler Output

The Journey to a Safer Frontend: Why Gusto Removed React.FC

Gusto Engineering did something that sounds radical but makes perfect sense once you see the reasoning: they removed React.FC from over 5,000 files.

React.FC is a TypeScript utility type that adds implicit children and can weaken type checking in subtle ways. The problems: it allows invalid default props, hides unused props, and breaks generic type inference. None of these are obvious until you dig deep.

Through automated codemods, they migrated everything to explicit prop typing with clear return types. The payoff? Dozens of hidden bugs caught during migration. ESLint rules now enforce the new pattern going forward.

Here's what gets me: they didn't do this because React.FC was broken. They did it because it was silently costing them. Type safety isn't just about catching obvious mistakes — it's about the quiet bugs that hide in the margins. The ones that only manifest when a user hits a specific edge case at 2 AM.

If you're using React.FC in a large codebase, this is worth a serious look. The migration effort pays for itself quickly.

The Journey to a Safer Frontend

The Duality of Language Models in the Browser

Dave Rupert's take on small language models (SLMs) running in the browser is worth sitting with. The appeal is real: local execution, no API keys, no per-token costs, lower energy use, and a low barrier to prototyping.

But Mozilla raised concerns that deserve attention: model calcification (sites optimizing for Google's specific model), model neutrality (Google's terms of service becoming the de-facto standard), and the false promise of universal access when GPU-equipped devices are actually required.

The browser APIs from Chrome and Edge — Prompt, Summarizer, Rewriter — are genuinely interesting. The ability to run inference locally without sending data to a server changes the privacy equation significantly.

But we should be honest about what "in-browser" means. It doesn't mean "runs on any device." It means "runs on devices with decent GPUs." That's not universal access — it's a different kind of exclusion.

Proposed alternatives include a bring-your-own-model marketplace, better fallbacks for low-end devices, and spec-level guidance on what's not allowed. Worth watching how this develops.

The duality of language models in the browser

ml-sharp-web: Gaussian Splats in the Browser

This is exactly the kind of thing that makes browser-based ML exciting. ml-sharp-web lets you upload a single image and generate a 3D Gaussian splat entirely in the browser using Apple's SHARP model.

The stack is React, TypeScript, Vite, and Bun. The model runs via ONNX Runtime Web and WebAssembly. You get a preview of the 3D scene and can download a .ply file.

The technical setup is non-trivial — the model is about 2.4 GB — but the instructions are beginner-friendly and the project includes troubleshooting for common WASM and ONNX issues.

What's notable is how browser-native this is becoming. Not long ago, this kind of ML work required server-side processing or native apps. Now it's running in Chrome with WebGPU and WASM. The gap between "requires a cluster" and "runs in my browser" keeps shrinking.

GitHub - bring-shrubbery/ml-sharp-web

Key Takeaways

Svelte 5's animation library is a practical win for teams wanting polished interfaces without the build-it-yourself overhead.
The "compiler output" framing for AI code is useful — we're not trying to stop AI from writing code, we're trying to build verification infrastructure.
Removing React.FC paid off for Gusto with real bugs caught. The migration cost is worth the type safety gained.
Browser-based SLMs have real promise but we should be honest about device requirements and vendor lock-in risks.
Gaussian splats in the browser with WebGPU/WASM is another sign that the browser is becoming a first-class ML platform.

Why Do I Care?

I'm writing this from a place of trying to figure out what's actually useful versus what's just shiny. The Svelte animations are genuinely useful — I've already bookmarked them for a project. The Gusto React.FC story hits because I've been burned by implicit type weakening before.

The AI verification piece feels like the most important infrastructure work happening right now. Not the AI itself — the stuff we build around it to make it trustworthy. That's where the real engineering challenge lives.

The browser ML stuff keeps getting more real. Every few months something that "required a server" becomes "runs in my browser." That's a trajectory worth watching.