What your .NET exceptions are telling attackers (and how to stop it)
6 minutes by Adrian Bailador

Unhandled exceptions in .NET APIs expose stack traces, database schemas, and internal paths to anyone watching. Adrian explains how to implement secure error handling in ASP.NET Core to protect your application without sacrificing observability.

Your .NET code is moving at 2026 speeds. Your CI is still in 2015.
sponsored by Depot

Every build: cold VM, restore packages, rebuild from scratch. Depot CI is a new CI engine that runs your existing GitHub Actions workflows — but jobs start in 2-3 seconds, steps run in parallel, and you can SSH into a failing build instead of reading logs. One command to migrate, $0.0001/sec to run. Same YAML, same actions, no rewrite.

The evolution of validation techniques in ASP.NET
8 minutes by Bipin Joshi

Bipin describes how validation in ASP.NET started as a UI feature tied to page controls in Web Forms, then moved to model decorators in MVC, and finally became a pipeline service in ASP.NET Core. Today it runs automatically, rejecting bad requests before they reach business logic. Blazor brings back stateful UI but keeps validation model driven. Across all versions, validation shifted from a convenience tool to a core part of how systems enforce boundaries.

Speed up .NET CI with test sharding
3 minutes by Gérald Barré

Test sharding splits your test suite into smaller subsets that run in parallel across multiple CI jobs, so you wait for the slowest shard instead of one long run. Meziantou.ShardedTest is a .NET tool that handles this by listing, sorting, and distributing tests across shards automatically. Gérald argues that it works well when your test stage is slow, but adds little value if tests are small or mostly waiting on IO. He suggests you can combine it with built-in framework parallelization for even faster feedback.

MAUI Avalonia now supports Linux and WebAssembly
6 minutes by Tim Miller

Avalonia now has a backend for .NET MAUI, letting developers deploy MAUI apps to Linux and WebAssembly. Setup takes just four steps and requires no extra bootstrapping code. The project also improved Avalonia itself, including new navigation controls now available to all Avalonia 12 users. Both native and drawn UI options are supported, giving developers more flexibility over how their apps look across platforms.

.NET synchronisation APIs: Out-of-process synchronisation
6 minutes by Ricardo Peres

This is the second in a series of posts on .NET synchronisation. Ricardo talks about using the synchronisation APIs in out-of-process context, meaning, to synchronise different processes, not threads. This can be achieved out of the box with three synchronisation objects: Mutex, Semaphore and EventWaitHandle. Ricardo also describes Shared files which offer another option but can leave stale locks after a crash. On Windows, you can also control access using permissions tied to specific users or groups.

And the most popular article from the last issue was:

• .NET synchronisation APIs: In-process synchronisation

Apple's most legendary computer has two legacies: there's the computer itself, and there's the commercial. That commercial. Only a couple of days before Steve Jobs debuted the computer that would both help cement his legacy and contribute to his unceremonious exile from Apple, the company dropped a Super Bowl ad that is still one of the most iconic commercials of all time. It raised both the hype and the stakes for the Macintosh in a big way.

The Macintosh wasn't a great computer, at least at first. It didn't have enough memory; there wasn't enough software that supported it; it wasn't customizable in the ways PC users needed at the time. I …

Read the full story at The Verge.

Claire Vo is the host of our sister podcast, “How I AI,” a former product executive and engineer, and founder of an AI startup called ChatPRD. Claire now runs her business, podcast, and family life with the help of nine OpenClaw agents running on multiple Mac Minis and old laptops. In this episode, Claire shares her journey from OpenClaw skeptic (it deleted her family calendar the first time she tried it) to true believer, and gives a masterclass in using AI agents in real life.

We discuss:

1. The exact step-by-step process to install and set up OpenClaw (it’s easier than you think)

2. How to avoid the biggest OpenClaw mistakes (don’t install it on your main computer)

3. Actual use cases that have changed Claire’s life (e.g. family scheduling, inbound sales, podcast prep, and course management)

4. Why multiple specialized agents beat one general-purpose agent

5. The security risks everyone worries about—and how to handle them

6. Browser limitations, memory issues, and practical workarounds

—

Brought to you by:

Mercury—Radically different banking

Omni—AI analytics your customers can trust

Orkes—The enterprise platform for reliable applications and agentic workflows

—

Where to find Claire Vo:

• X: https://x.com/clairevo

• LinkedIn: https://www.linkedin.com/in/clairevo

• Podcast: https://www.youtube.com/@howiaipodcast

• Website: https://clairevo.com

• ChatPRD: https://www.chatprd.ai

—

Where to find Lenny:

• Newsletter: https://www.lennysnewsletter.com

• X: https://twitter.com/lennysan

• LinkedIn: https://www.linkedin.com/in/lennyrachitsky/

—

In this episode, we cover:

(00:00) Introduction to Claire and OpenClaw

(08:00) The journey from OpenClaw skeptic to believer

(11:50) What OpenClaw actually does that’s useful

(13:35) OpenClaw vs. other AI agent products

(17:05) How to actually install OpenClaw: the basics

(18:49) Setting up like you’d onboard a real assistant

(20:41) Security and privacy considerations

(24:53) Live demo: Installing OpenClaw step-by-step

(28:47) Setting up Q: an agent for her kids’ homework

(34:08) Understanding “soul,” “identity,” and “memory”

(40:40) The unlock: multiple agents, not just one

(45:02) How to run multiple agents on one machine

(47:28) Jesse Genet’s homeschooling use case

(49:58) Real examples and use cases

(56:41) Finn, Claire’s family agent

(1:00:05) Sage the Course Bot

(1:02:15) Common issues and workarounds

(1:08:08) The Exa/Perplexity web search workaround

(1:09:29) Memory management and context overload

(1:12:09) Pro tip: Screen sharing to manage Mac Minis

(1:14:18) Using Google Workspace for agent collaboration

(1:16:24) What makes OpenClaw special

(1:20:15) The “yappers API” and ramble mode

(1:22:04) Using Claude Code as your OpenClaw brain surgeon

(1:25:16) Bringing management skills to AI agents

(1:29:32) Why this matters

(1:32:37) Lightning round and final thoughts

—

Referenced:

• OpenClaw: https://openclaw.ai

• Claude Cowork: https://claude.com/product/cowork

• Fry’s Electronics: https://en.wikipedia.org/wiki/Fry%27s_Electronics

• Peter Steinberger on LinkedIn: https://www.linkedin.com/in/steipete

• Telegram: https://telegram.org

• WhatsApp: https://www.whatsapp.com

• Fin: https://fin.ai

• Why OpenClaw feels alive even though it’s not (this AI has a heartbeat but not a brain): https://x.com/clairevo/status/2017741569521271175

• 5 OpenClaw agents run my home, finances, and code | Jesse Genet: https://www.youtube.com/watch?v=96Vl8s3EQhk

• Executive Playbook for AI in Engineering, Product, and Design: https://maven.com/clairevo/ai-native-epd-org

• Zach Davis on LinkedIn: https://www.linkedin.com/in/zach-m-davis/

• ChatGPT Atlas: https://chatgpt.com/atlas

• Perplexity Comet: https://www.perplexity.ai/comet

• Browser (OpenClaw-managed): https://docs.openclaw.ai/tools/browser

• Buffer: https://buffer.com

• Brave: https://brave.com/search/api/

• Exa: https://exa.ai

• Hilary Gridley on X: https://x.com/yourgirlhils

• How to become a supermanager with AI: https://www.lennysnewsletter.com/p/how-to-become-a-supermanager-with

• How custom GPTs can make you a better manager | Hilary Gridley (Head of Core Product at Whoop): https://www.youtube.com/watch?v=xDMkkOC-EhI

• How to debug a team that isn’t working: the Waterline Model: https://www.lennysnewsletter.com/p/how-to-debug-a-team-that-isnt-working

• Jensen Huang on LinkedIn: https://www.linkedin.com/in/jenhsunhuang

• How I built a 1M+ subscriber newsletter and top 10 tech podcast | Lenny Rachitsky: https://www.lennysnewsletter.com/p/how-i-built-a-1m-subscriber-newsletter

• Age of Attraction on Netflix: https://www.netflix.com/title/81779095

• Oura Ring: https://ouraring.com/

• Eight Sleep: https://www.eightsleep.com

• Hoopsalytics: https://hoopsalytics.com

• DJI Osmo smartphone gimbal: https://www.amazon.com/DJI-Stabilizer-Tracking-Extension-Stabilization/dp/B0FJ2L67HJ?ref_=ast_sto_dp

• Silent basketball: https://www.amazon.com/Rzkipdy-Silent-Basketball-Size-27-5/dp/B0FHFSQWPP/ref=sr_1_9

• Marc Andreessen: The real AI boom hasn’t even started yet: https://www.lennysnewsletter.com/p/marc-andreessen-the-real-ai-boom

—

Recommended books:

• Treasure Island: https://www.amazon.com/Treasure-Island-Robert-Louis-Stevenson/dp/1505297400

• Alice’s Adventures in Wonderland: https://www.amazon.com/Alices-Adventures-Wonderland-Illustrated-Illustrations/dp/991673268X

• Charts for Babies: A Picture Book: https://www.amazon.com/Charts-Babies-Picture-Book/dp/1419785184

—

Production and marketing by https://penname.co/. For inquiries about sponsoring the podcast, email podcast@lennyrachitsky.com.

—

Lenny may be an investor in the companies discussed.

The mass adoption of WebAssembly has yet to be realized. 

The true turning point for WebAssembly — specifically its ability to ship lightweight code to any number of endpoints with millisecond latency — rests on finalizing the component model.

“The true turning point for WebAssembly — specifically its ability to ship lightweight code to any number of endpoints with millisecond latency — rests on finalizing the component model.”

Standardizing the component model will allow WebAssembly to replace containers in areas where they typically struggle, regardless of whether Kubernetes is involved. Wasm is better suited for edge devices, serverless environments, and event-driven deployments that require pushing updates to an unlimited number of endpoints simultaneously.

Indeed, WebAssembly has moved far beyond the browser. It shows its maturity via reliable production use across servers, CDNs, and backend services, as well as its broad applicability. 

While core WebAssembly is intentionally low-level and difficult to use directly, recent specification work enables higher-level abstractions. Reference types and interface types allow components to expose meaningful APIs without developers needing to understand WASM internals, making the technology more accessible to engineers.

During this talk, “Towards a Component Model 1.0” at Wasm I/O in Barcelona last week, Luke Wagner of Fastly described efforts to make the so-called Component Model easier to adopt, including motivating native browser implementations and closing a few remaining functionality gaps.

“Achieving a ‘just works’ developer experience requires standards-based answers to coordinated problems… such as how a standard library performs IO or how multiple modules are bundled and linked at runtime.”

While technical improvements like debugging and threading are important, the “higher order bit” for explosive Wasm adoption is a lack of upstream support in popular languages and frameworks, Wagner said.

Achieving a “just works” developer experience requires standards-based answers to coordinated problems, such as how a standard library performs IO or how multiple modules are bundled and linked at runtime. To address this, the strategy involves two layers: the component model, which provides foundational answers for computation and virtualization, and WASI, which defines modular standard APIs for various types of IO, Wagner said.

“I’m going to claim, perhaps contentiously, that a lack of upstream support for all the popular languages, tools, factors, and frameworks so that Wasm can just work both inside and outside the browser is holding up Wasm’s adoption,” Wagner said.

Wagner said WebAssembly Preview 2 factored out the component model layer, while the upcoming Preview 3 extends it to handle concurrency with async functions, strings, and futures. This concurrency feature will serve as a major milestone towards completing the component model.

Moving from “eager” memory allocation to a “lazy” API to reduce heap fragmentation and improve performance by inverting control flow is also planned. Other planned improvements for 1.0 include supporting multi-value returns, adding error context values, and introducing a GC API option for languages that use garbage-collected memory, Wagner said. 

“With Preview 3, we’re extending a Wasm module to provide answers to a lot of concurrency questions. And as part of that, finding async functions, strings, and futures as first-class concepts,”  Wagner said. “So, lots of benefits come from this lazy API. But how do we change the API by maintaining that all-important stability, guarantee that I just mentioned?”

Meanwhile, the component model provides standards-based answers to open questions, allowing for “upstream support everywhere, so the host can just work,” Wagner said. “We’ve got a preview for release coming very soon, followed by cooperative threads and a minor release that gives us answers to a bunch of hard concurrency questions,”  Wagner said. 

To encourage native browser support, Wagner highlighted JCO, a tool that transpiles components into JavaScript and core WebAssembly that runs in browsers today. Native support would offer performance gains by avoiding JS glue code and allowing direct calls from Wasm into browser code. 

 Wagner concluded his talk with a callout to the community to make pull requests that help simplify the component model by building shared tooling around guest and host APIs. The project can also use contributions for more documentation to keep pace with commits.

Contributions for upstreaming and cross-language tooling, and closing key expressivity gaps with features like optional imports, callbacks, subtyping, and more, are also needed, Wagner said.

“And so what I’d ask from everyone here is to use Preview 3 once it’s released, use JCO to simplify your web developer experience with Wasm,”  Wagner said. “And if any of these many Bytecode Alliance projects I mentioned sound interesting, please contribute and say hi to us on Bytecode Alliance at Zulip, and you can read and discuss the component model spec on the GitHub repo.” 

The post WebAssembly is now outperforming containers at the edge appeared first on The New Stack.