Hey,

Sorry for skipping last week. I had a super busy weekend and could not spend a single minute on FullStack Bulletin. I am also rushing this weekend, so I will keep this editorial short, but I promise the curation got all my attention and time.

The last couple of weeks have been packed with different projects, so my reading has been a bit all over the place. You will notice that in this issue. It moves from streams performance and WebAssembly direction, to CSS and UI details, plus some honest thinking about AI and how it is changing how we build.

Also, do not skip the extra links at the bottom. There are a few gems there that did not make the top picks, and it was a genuinely hard call.

Happy learning and building!
— Luciano

"The thing is, you can't fake drive. If you try to, you can easily burnout"
—Sophia Turner, Engineer

We Ralph Wiggumed WebStreams to make them 10x faster. The title is a Ralph Wiggum joke, but the post is the real deal. Vercel profiled Next.js server rendering and found that a big chunk of the cost was not your app code. It was the WebStreams API itself, with lots of Promise work, per chunk allocations, and microtask churn. So they built a faster WebStreams implementation that can route the hot paths through Node’s internal streams when possible. The numbers are honestly nuts. Their React Server Components byte stream pattern jumps from about 110 MB per second to about 1,600 MB per second, roughly a 14.6x boost. What really surprised me is how much of this they got by letting AI do a lot of the grinding, with tests and benchmarks acting like the guardrails. I’m impressed that this approach can land results like this. I’m also a little uneasy about it, since it can feel like brute force instead of understanding. The best part is it is not staying locked inside Vercel. There is already work underway to bring the same wins into Node.js core, which means everyone could benefit. If you do server side rendering or stream heavy work in Node, this is worth your time. Read Article

We Deserve a Better Streams API for JavaScript — And speaking of WebStreams, here is the companion piece you did not know you needed. James Snell from Cloudflare, who has implemented WebStreams in both Node.js and Cloudflare Workers, makes a very compelling case that the standard API has fundamental usability and performance problems that go beyond what incremental fixes can solve. The WHATWG Streams spec was designed before async iteration even existed in JavaScript, and that timing shaped everything: the manual reader acquisition, the locking model that permanently breaks streams if you forget releaseLock(), the BYOB complexity that almost nobody uses in practice. James presents an alternative approach built around modern JavaScript language primitives that runs anywhere between 2x and 120x faster than standard WebStreams across every runtime he tested. Together with the Vercel piece above these two articles paint a really clear picture of where JavaScript streaming is heading and why we should all care about it, whether we work on the server, the edge, or the browser. Read Article

Making WebAssembly a First-Class Language on the Web — This Mozilla Hacks article articulates something I have felt for a while but could never quite put into words. WebAssembly works on the web, sure, but it feels like a second class citizen. You cannot just drop a .wasm file into a script tag. You need JavaScript glue code to access any Web API, and that glue must be regenerated for every source language. The article walks through exactly why that is the case, comparing the developer experience curve of JavaScript, which is a nice gradual slope, to WebAssembly, which hits a wall of complexity almost immediately. The exciting part is the proposed solution through WebAssembly Components, which would give Wasm modules a standardized way to describe and use Web APIs directly, no JavaScript glue required. If this lands it could genuinely change who uses WebAssembly and for what, lowering the bar from big companies with dedicated toolchains to any developer who just wants to ship a Rust or C++ module to the browser. Read Article

Sprites on the Web — Josh Comeau never disappoints and this one is a delightful blend of nostalgia and modern CSS. If you have been building for the web long enough you probably remember sprite sheets from the early days, those long image strips where you shifted background-position to animate things. Josh takes that old school technique and brings it into the modern era using object-fit, object-position, and the beautifully obscure steps() CSS timing function. The interactive examples make the whole thing click instantly. What really got me though is the practical argument: compared to an animated GIF you get full control over timing and play state, better image format support like AVIF, dramatically smaller file sizes, and everything stays crisp at any resolution. It is one of those articles that makes you want to immediately open your editor and try it out. If you are looking for a way to add some personality to a UI without heavy JavaScript animation libraries this is your answer. Read Article

Potentially Coming to a Browser :near() You — I love a good CSS proposal and this one is genuinely clever. The idea is a :near() pseudo class that fires when the pointer gets close to an element, not just when it hovers directly over it. Think of those share buttons that only appear when you hover an image: with :near() you could reveal them when the cursor is within a certain distance, making the interaction much more forgiving and discoverable. The article does not stop at visual effects though. It explores how the underlying concept could improve the Interest Invoker API for hover triggered popovers and even feed into the Speculation Rules API for smarter prefetching. What I appreciate most is that the author actually simulates :near() with real CSS workarounds so you can see and feel the difference today, even though no browser supports it yet. It is the kind of thing that once you see it you wonder how we have managed this long without it. Read Article

mcollina/skills: AI-Assisted Node.js Development Skills — Just the other day, I was thinking it would be cool to have a skill for writing really good Node.js code with AI agents. Well, you hope and the world delivers. In this case Matteo delivers, so thanks Matteo... Matteo Collina has been one of the most influential voices in the Node.js ecosystem for years, from Fastify to Pino to his work on Node.js core, and now he has open sourced his personal collection of skills for AI assisted development. If you are not familiar with the concept, skills are curated sets of best practices and context that you feed to AI coding tools so they produce better, more idiomatic code for your stack. Matteo's collection covers Fastify, Node.js core internals, TypeScript, OAuth, linting with neostandard and ESLint v9, and even deep Node.js C++ addons and V8 work. If you are using Claude Code, Cursor, or any similar tool for Node.js development this is an incredibly practical resource. It is also a great example of how experienced engineers can encode their hard won knowledge into something that scales through AI. I would love to see more people in the community sharing their own skills like this. Check Repo

The Factory Model: How Coding Agents Changed Software Engineering. Lately we have been leaning more and more into AI assisted coding, and it is honestly inescapable at this point. We have also featured a bunch of great pieces by Addy Osmani here, so you will not be surprised to see another one. This one is genuinely worth your time. It also matches a feeling I have mentioned here before, that AI is nudging us from being artisans who shape every line by hand into managers who run factories that produce code. It is less about perfect detail, and more about shipping at scale while keeping quality under control. Addy gives a mental model for what a lot of us are living through. The shift is from writing code to orchestrating systems that write code. His analogy is a factory: you define specs, spin up agents in parallel, review what comes back, then iterate. What I appreciated most is that he is clear about what does not change. Clear requirements, strong abstractions, reliable tests, and careful tradeoffs still matter. If your spec is vague, you do not just slow down one developer anymore. You multiply confusion across a whole fleet of runs. The section on why test driven development becomes close to mandatory in an agent workflow really hit home for me. If you have been using AI coding tools and wondering how your role changes, and what good looks like going forward, this is essential reading. Read Article

📕 Book of the week!

Introduction to the Theory of Computation, by Michael Sipser

Gain a clear understanding of even the most complex, highly theoretical computational theory topics in the approachable presentation found only in the market-leading INTRODUCTION TO THE THEORY OF COMPUTATION, 3E. The number one choice for today's computational theory course, this revision continues the book's well-know, approachable style with timely revisions, additional practice, and more memorable examples in key areas. A new first-of-its-kind theoretical treatment of deterministic context-free languages is ideal for a better understanding of parsing and LR(k) grammars. You gain a solid understanding of the fundamental mathematical properties of computer hardware, software, and applications with a blend of practical and philosophical coverage and mathematical treatments, including advanced theorems and proofs. INTRODUCTION TO THE THEORY OF COMPUTATION, 3E's comprehensive coverage makes this a valuable reference for your continued studies in theoretical computing.

Buy on Amazon.com - Buy on Amazon.co.uk

More quality content coming your way! ⭐

• Parse, Don't Validate — and Type-Driven Design in Rust
• BuildKit: Docker's Hidden Gem That Can Build Almost Anything
• Embrace the Chaos: The Shape and Flow of Masonry Layouts
• Secure Massively Multiplayer Snake
• Stop Putting Secrets in .env Files
• Simple Made Inevitable: The Economics of Language Choice in the LLM Era
• What's !important?
• Yet Another Way to Center an Absolute Element
• The Inner Workings of TCP Zero Copy
• Thread-per-core and io_uring
• Solving the Nebraska Problem with the Open Source Endowment
• You Can Use Newline Characters in URLs
• Web Origami
• blogat.to: Static Site generator for Gleam
• prek: Preview and execute commands interactively
• GitHub Copilot Prompt Injection via Commit Messages

End of transmission! 📡

Mission complete! If you loved it, learned something, or want to suggest improvements, reply and let us know – we thrive on your feedback! 🌱