Open Source AI Coding Agents Hit Critical Mass: OpenCode and Google's Stitch Drop Same Week

Hey everyone, welcome to Builder's Briefing for March twenty-second, twenty-twenty-six. I'm Alex, joined as always by Sam. We've got a packed one today — open source coding agents hitting a tipping point, some really interesting model drops, and a Rust-versus-TypeScript performance story that might change how you think about WASM.

Yeah, and someone built a Bluesky client in Fortran, so we'll get to that too. Let's go.

Alright, the big story. Two serious open-source AI coding agents dropped in the same week. OpenCode — which blew up on Hacker News, over six hundred fifty points — is positioning itself as the open-source Cursor alternative. It's terminal-native, MIT-licensed, and you fully own it. And then Google Labs quietly shipped Stitch Skills on GitHub, their own open-source coding agent with a composable skills architecture.

Okay, so what jumps out to me is how different the design philosophies are. OpenCode is very much a CLI-first tool — if your team already lives in the terminal, it just slots right in. Stitch is doing this modular plugin-style thing where you compose skills together. It's almost like Google is betting that the agent itself is less important than the building blocks.

Exactly. And both are MIT-licensed, both ready to self-host today. So if you've been paying twenty bucks a month for a proprietary coding assistant, you now have two credible alternatives with no vendor lock-in. You can wire them into your own CI/CD pipelines, customize them however you want.

Right, and what's wild is the implication for the next six months. Coding agents are commoditizing fast. The moat isn't the agent anymore — it's the context you feed it. Your codebase, your conventions, your deployment pipeline. That's where the value lives now.

If you're building developer tools or internal platforms, seriously evaluate both of these this week. Links in the briefing.

Okay, let's talk models. A few notable drops. The vLLM project launched vllm-omni — basically a unified inference path for text, image, audio, and video. If you're already using vLLM in production, this is huge because you don't have to stitch together separate pipelines anymore.

That's interesting because multimodal serving has been such a pain point. Everyone's been cobbling together different services for different modalities. Having one inference path through vLLM could really simplify production stacks.

Also worth flagging — Mamba-3 dropped from Together AI. Each generation of these state-space models closes the quality gap with transformers, and if you're doing inference on long sequences where attention costs are killing your margins, Mamba's linear-time inference is looking more and more viable.

And Meta published research on machine translation covering sixteen hundred languages. Sixteen hundred! That's approaching coverage for a lot of low-resource languages that have basically been invisible to translation tech until now.

Yeah, watch for model weights to follow on that one. If you're building for global markets, this is a signal worth tracking.

Alright, developer tools. This one's my favorite story of the day. The OpenUI team had a parser written in Rust compiled to WASM for the browser. They rewrote it in plain TypeScript — and it got faster.

Okay, I need to unpack that because on the surface it sounds like heresy. But the takeaway isn't that Rust is slow. It's that the WASM serialization boundary — crossing between JavaScript and WASM — has real overhead. For certain workloads, that overhead completely negates Rust's raw speed advantage.

Exactly. So the practical lesson: before you reach for Rust plus WASM for browser-side performance, benchmark the JavaScript-native path first. You might be surprised.

Also quickly — Iroh is worth a look if you're building peer-to-peer or local-first apps. It's a Rust networking stack where you dial cryptographic keys instead of IP addresses. NAT traversal just handled for you. That's a big deal for anyone who's spent weeks fighting hole-punching.

Oh, and Ubuntu twenty-six-oh-four will finally show asterisks when you type your sudo password. Only took forty-six years.

Ha! Update your onboarding docs, everyone. No more telling new developers 'don't worry, it's actually typing.'

Shifting gears — there's a concerning signal out of Deno. Reports of layoffs, questions about leadership visibility. The Hacker News thread has about a hundred seventy points and real accounts from affected people.

This isn't a death notice, but if you've bet your stack on Deno or Deno Deploy, it's time to at least have a migration plan in your back pocket. Risk management, not panic.

On the security side, the EFF put out a piece arguing that sites blocking Internet Archive crawlers to prevent AI training are really just hurting themselves. AI companies have plenty of other data sources — but the historical web record through the Archive is irreplaceable.

That's a really important nuance. If you maintain a robots.txt, be surgical about it. Blocking AI training crawlers is one thing, but blanket-blocking archive.org alongside them means you're erasing your own history from the web's collective memory.

Quick hits! Armin Ronacher — the creator of Flask — has a nice reflection out about why some things just take time in software. Worth a read. There's an FFmpeg one-oh-one guide resurfacing on Hacker News that's a solid reference if you ever touch video.

And someone built a terminal-only Bluesky client in Fortran. I just want to know who woke up and said, you know what this social network needs? Fortran.

Living legend behavior, honestly. Also check out Grafeo if you need an embeddable graph database without running full Neo4j — really interesting for AI apps and local-first tools. Links to everything are in the briefing.

So here's the takeaway for this week. The coding agent layer is commoditizing right now. OpenCode and Google Stitch both going open source means the value isn't in having an AI coding assistant — it's in what context and workflows you feed it. Integrate one of these open agents and focus your differentiation on your proprietary context.

And don't sleep on the TypeScript-versus-WASM lesson. Abstraction boundaries have real costs. Benchmark before you assume the fancier tool is the faster tool.

That's the briefing for March twenty-second. This coming week, keep an eye on whether more open-source coding agents emerge — I think we're at the start of a wave, not the end. Thanks for listening, everyone.

Go build something cool. See you next time.