TSRX, Warp Goes Open Source, and the Question of What Engineers Are Actually For
Published on 30.04.2026
TLDR
A TypeScript language extension called TSRX is making the rounds as a potential successor to JSX, offering cleaner syntax for humans and AI alike. Meanwhile, Warp terminal just went open source, Poolside shipped two new agentic coding models, and Kent C. Dodds wrote something worth sitting with about what software engineers are actually for in the age of AI agents.
TSRX: JSX, But With Actual Control Flow
I keep thinking about this one. TSRX (TypeScript Render Extensions) is a compiler exposed as a Vite plugin, created by Dominic Gannaway, who previously worked on the React and Svelte core teams and built Inferno. The pitch is a "spiritual successor to JSX" that stays backwards compatible with TypeScript but lets you write UI components with real control flow rather than ternary soup.
The syntax is genuinely interesting. You can call hooks conditionally because the compiler lifts conditional branches into their own components automatically. No more manually splitting a component just to gate a useUser() call behind an if. Styles live in the same file as the component. Variables can be declared mid-template and stay scoped to their surrounding block. The result reads more like how you'd describe the UI to a colleague than what JSX forces you to write.
The framing around AI readability is worth taking seriously. The TSRX docs cite research showing language models attend unevenly to long contexts, performing best when relevant information sits close together. Whether you believe that or not, the ergonomic case for co-location stands on its own. Less jumping around between logic and markup is better for human readers too. TSRX compiles to React, Preact, Solid, Ripple, and Vue today, with a language server, Prettier plugin, and ESLint support. Interoperability with existing TSX codebases means you can adopt it incrementally.
TSRX | TypeScript Language Extension for Declarative UI
Scaling Vibe-Coded Apps: The ClawHub Story
This Convex post is a fun read because it's honest about something most engineering content isn't: vibe-coded apps have real architectural debt, and that debt eventually shows up in your bandwidth bill. ClawHub, a skill registry for AI agents, hit 1 million weekly users with code that was reading 17 MB per browse-page query. After applying a series of incremental optimizations, that same query reads around 20 KB.
The patterns described are database basics dressed up for a reactive backend, but they're useful: prefer one-shot fetches over reactive subscriptions for public catalog pages, build digest tables to avoid full document reads and multi-table joins, add change detection before writing to highly-subscribed tables so you don't trigger thundering herds for no-op updates, and use compound indexes instead of post-query filtering.
What makes it worth reading is the operational texture. The team ran eight optimization cycles over four days while the site was serving real traffic. No maintenance windows. The point about "Convex will let you iterate quickly, then give you the tools to make things scale another 1000x" is the kind of concrete promise that either ages well or doesn't, but the optimization loop described is solid regardless of backend.
Site Up. Costs Down: Optimizing OpenClaw's 1M Weekly Active Users
Warp Goes Open Source
Warp terminal just open sourced its client codebase. This is notable because Warp has been one of the more polished terminal experiences in recent years, built in Rust, with a coding agent built in and support for bringing your own CLI agent (Claude Code, Codex, Gemini CLI, etc.). OpenAI is the founding sponsor of the open-source repository, and the new agentic management workflows are powered by GPT models.
The contribution model is worth noting: Warp uses AI agents to triage issues, write specs, implement changes, and review PRs, with a build dashboard at build.warp.dev where you can watch active agent sessions in a web-compiled Warp terminal. That's either a compelling demo of agentic development in practice or a lot of theater depending on your disposition, but it's a real thing you can watch. AGPL v3 for most of the code, MIT for the UI framework crates.
Poolside Ships Two Agentic Coding Models
Poolside released Laguna XS.2 and Laguna M.1, both trained from scratch on 30 trillion tokens for agentic coding specifically. Laguna XS.2 is open weight under Apache 2.0, a 33B Mixture of Experts model with 3B activated parameters, available on Hugging Face. Laguna M.1 is their flagship: 225B total parameters, 23B activated, trained on 6,144 interconnected NVIDIA H200 GPUs.
Poolside was founded by former GitHub CTO Jason Warner, which is the detail the newsletter chose to note. The models are available on OpenRouter and through a dedicated API. The benchmarks are on SWE-bench Verified, SWE-bench Multilingual, SWE-bench Pro, and Terminal-Bench 2.0. Whether these models actually hold up in day-to-day use beyond benchmark conditions is the question worth asking, as always, but an Apache 2.0 open-weight 33B MoE model built specifically for agentic coding is worth trying.
Two foundation models built for agentic coding
Matt Pocock's Agent Skills: Engineering Fundamentals, Not Vibe Coding
Matt Pocock published a set of Claude Code skills built around classic engineering principles, framed explicitly as an alternative to the "just ship something with AI" approach. The skills cover things most developers skip when working with agents: aligning on what you're actually building before you start (/grill-me, /grill-with-docs), building a shared language between you and the agent so it stops using 20 words where one will do, TDD with a red-green-refactor loop (/tdd), and diagnosing bugs methodically instead of asking the agent to guess (/diagnose).
The /improve-codebase-architecture skill is the one I'd reach for most. Agents accelerate software entropy because they can write a lot of code fast. Running an architectural review pass every few days sounds like discipline worth having. The caveat is that skills are only as good as the model following them, and the failure modes Pocock is addressing are real, so having written conventions helps. Quick install: npx skills@latest add mattpocock/skills.
Trees: A File Tree Library From Pierre
The Pierre Computer Company, the team that previously built the excellent @pierre/diffs library, released @pierre/trees, an open-source file tree rendering library. It's built for performance with built-in virtualization (2,956 files with all folders expanded render fine), full keyboard navigation and ARIA roles, Git status badges, drag and drop, search, scoped CSS theming via OKLCH color variables, and Shiki theme support if you're already using it for code highlighting.
File trees sound boring until you need one. The implementation details here are good: flatten empty directories, context menus with composition, sticky folders during scroll. This is the kind of library that saves days of work if you're building anything IDE-adjacent, a code review tool, or a file browser.
RSC Is More Than Serialization
Daishi Kato, the author of Jotai, Zustand, and Waku, wrote a short but thoughtful piece on RSC. His initial take when building Waku was that RSC was essentially a serialization protocol, something you wire up to pass data from server to client. Over time, working with the React team and adding support for libraries like react-tweet and the AI SDK, his view shifted. RSC is an architectural design with opinions about request patterns, single round-trips, and library interoperability baked in.
The practical point is that a good RSC framework shouldn't just expose the serialization primitive. It should guide you away from client-server waterfalls, which are exactly what RSC was meant to solve. That's a useful lens for evaluating frameworks claiming RSC support. Does it make the right pattern easy or does it just give you the rope?
My Thoughts on RSC: Is It Just Serialization?
The Last Software Engineer
Kent C. Dodds wrote something worth reading slowly. The framing: fast-forward to the point where AI agents handle all current software development value, then take one step back. What's the last valuable thing a software engineer offers?
His answer is judgment: deciding what is worth making real, what constraints can't be violated, what trade-offs are acceptable. Not writing code. Not choosing libraries. Not designing implementations. The scarce skill shifts from aim (hitting a given target reliably) to target selection (knowing which target is worth hitting at all). He calls this "product engineering" and the distinction from product management is deliberate. Product engineering means understanding the shape of the existing system, the cost of the change, the risks of implementation, and the experience users will have once the software exists and changes over time.
The part I find most compelling is the accountability argument. A system that doesn't bear the cost of being wrong can recommend a locally optimal choice that no responsible owner should accept. Someone still has to say "this is the future we're going to ship." What makes that sentence meaningful is that the person saying it is accountable for the consequences. The essay is worth reading even if you think the AI-takes-over-coding premise is overstated, because product judgment has always separated the best engineers from merely productive ones. It's just getting harder to ignore that gap now.
Key Takeaways
- TSRX is a TypeScript language extension that compiles to React, Solid, Vue, and others, offering conditional hook calls, co-located styles, and real control flow without ternary chains
- Scaling reactive apps requires matching subscription patterns to access patterns: one-shot fetches for catalogs, reactive subscriptions only where data genuinely changes frequently
- Warp terminal is now open source under AGPL v3, with a contribution model powered by AI agents you can watch in real time at build.warp.dev
- Poolside shipped Laguna XS.2 as an open-weight Apache 2.0 33B MoE model and Laguna M.1 as their 225B flagship, both trained specifically for agentic coding
- Matt Pocock's agent skills enforce engineering fundamentals (TDD, shared language, architectural review) as a counterweight to vibe-coded entropy
- The Pierre team's @pierre/trees library handles file tree rendering with virtualization, Git status, drag and drop, and Shiki theming
- Daishi Kato's RSC framing: it's an architectural design with opinions, not just a serialization protocol
- The shift in software engineering value is from implementation to judgment: deciding what should be built, not just what can be built