My goal for this series of posts is to share interesting links every two weeks, and I've noticed that sometimes it feels like a split second between when these posts go out. I'm actually a week or so late on this one, which is fine, but dang does time go by quickly. Usually summer is pretty slow, but with the new job, new product launch, and lots of camps for the kids, I don't feel like it's ever let up. Despite that, I've managed to put in near ten hours of Star Wars Outlaws this weekend, so I'm still getting a chance to catch my breath. I put the controller down for a bit so I can share these fun links with yall. Enjoy!

Using Transformers.js to Find Related Posts

Here's a really cool example of GenAI-style tech used for content - finding related posts using Transformers.js. The example given here is for a blog written in Astro, but could be applied to any other tech, like Eleventy. (And if someone asks, heck, I'll make an example of that.) For my blog, I'm using an API call with Algolia, but this solution would be all done on your server, and at build time. I'm not sure it would work for this blog due to the size of the content, but I may give it a shot later this week.

What Script is This?

Next up is an excellent look at something I've never considered before - using JavaScript to determine which script block/tag it exists in. In his post, Alex MacArthur looks at document.currentScript and how it could be helpful to web developers. This is a feature I've never heard of, and it's been around for a decade.

Using AI for Fitness

For the last link, I'll share a post that's both cool and inspiring, Using AI to Get Fit, by one of my best friends, Scott Stroz. In it he talks about how he made use of MCP, Claude, and Spotify, to help build a playlist to aid in his exercise routine.

Just For Fun

Next time you make a quick GitHub repository, hope and pray you aren't accidentally triggering a huge milestone.

The Model-View-ViewModel (MVVM) pattern has long been a cornerstone in building maintainable and testable UIs across frameworks like WPF, Xamarin, Uno Platform, and others. It provides a clean separation of concerns and enables powerful data binding. But despite its popularity and maturity, MVVM often introduces unnecessary complexity and friction—particularly when it comes to state management and event-driven UI updates.

Enter MVUX—a modern, state-driven evolution of MVVM inspired by unidirectional data flow architectures like Redux. MVUX simplifies UI development by shifting the focus from object binding and manual state tracking to declarative, immutable state and reactive updates. Let’s explore why developers should consider moving from MVVM to MVUX.

---

A Quick Overview of MVVM

MVVM is composed of three main components:

• Model: Represents the domain data or business logic.
• View: The UI layer (XAML, HTML, etc.).
• ViewModel: The intermediary that exposes data and commands for the View.

The View binds to the ViewModel using data binding (e.g., INotifyPropertyChanged in .NET). Commands are typically exposed as ICommand implementations for interaction handling.

Benefits of MVVM:

• Clear separation of UI and logic.
• Enables testing without a UI.
• Promotes reuse and abstraction.

But for all its benefits, MVVM has its share of pain points.

---

Limitations of MVVM

1. Boilerplate and Verbosity

MVVM often requires a lot of boilerplate: implementing INotifyPropertyChanged, managing backing fields, writing RelayCommands or DelegateCommands, etc.

csharpCopyEditprivate string _name;
public string Name
{
    get => _name;
    set
    {
        _name = value;
        OnPropertyChanged();
    }
}

This is repeated across most ViewModels, inflating code and reducing developer productivity.

2. State Synchronization is Hard

In MVVM, state is often distributed across multiple properties and can become difficult to track, especially in complex UIs. There’s no single source of truth for UI state.

3. Command Explosion

Every user interaction typically requires a dedicated command. This leads to an explosion of ICommand implementations or lambdas, often with overlapping responsibilities.

4. Implicit Flow and Debugging Difficulty

MVVM relies on implicit bindings between View and ViewModel. When things go wrong, debugging a broken binding or a misfired command can be a frustrating experience.

---

Introducing MVUX: A Better Way

MVUX (Model-View-Update-eXtended) is a modern take on state-driven UI development. It’s designed to reduce boilerplate, centralize state, and embrace unidirectional data flow with immutable updates—leading to simpler, more maintainable, and predictable UIs.

MVUX Core Concepts:

• State: A single immutable object representing the UI state.
• Reducers: Pure functions that return new state based on an input and the current state.
• Effects: Handle asynchronous operations like API calls or side-effects.
• View: Declaratively renders UI based on the current state.

---

Side-by-Side Example: Business Search

Application includes a service that exposes a SearchAsync method.

public interface IAbnLookupService
{
   ValueTask<IImmutableList<BusinessResult>> SearchAsync(string name, CancellationToken cancellationToken = default);
}

The MainPage of the application includes a TextBox where the user can enter a business name or ABN, and a ListView that displays the search results. Here is the MainViewModel as defined using MVVM (MVVM Toolkit).

public partial class MainViewModel : ObservableObject
{
    private readonly IAbnLookupService _abnLookupService;

    [ObservableProperty]
    private string _searchText = string.Empty;
    public ObservableCollection<BusinessResult> SearchResults { get; }

    [ObservableProperty]
    [NotifyPropertyChangedFor(nameof(CanSearch), nameof(SearchButtonText))]
    [NotifyCanExecuteChangedFor(nameof(SearchCommand))]
    private bool _isSearching = false;
    public bool CanSearch => !IsSearching;

    public string SearchButtonText => IsSearching ? "Searching..." : "Search";

    [RelayCommand]
    private async Task HandleEnterKeyAsync()
    {
        if (CanSearch)
        {
            await SearchAsync();
        }
    }

    public MainViewModel(IAbnLookupService abnLookupService)
    {
        _abnLookupService = abnLookupService;
        SearchResults = new ObservableCollection<BusinessResult>();
    }

    [RelayCommand(CanExecute = nameof(CanSearch))]
    private async Task SearchAsync()
    {
        var searchTerm = SearchText?.Trim();

        SearchResults.Clear();

        if (string.IsNullOrEmpty(searchTerm))
        {
            return;
        }

        // Show loading state
        IsSearching = true;

        try
        {
            var results = await _abnLookupService.SearchAsync(searchTerm);
            SearchResults.AddRange(results);
        }
        finally
        {
            // Reset button state
            IsSearching = false;
        }
    }
}

In addition to basic properties for SearchText and SearchResults, the MainViewModel exposes properties IsSearching and SearchResultText that are used to control the appearance of the Search button.

Here’s the equivalent using MVUX.

public partial record MainModel(IAbnLookupService abnLookupService)
{
    // State for search text
    public IState<string> SearchText => State<string>.Value(this, () => string.Empty);

    // Feed for search results
    public IListFeed<BusinessResult> SearchResults =>
        SearchText
            .Where(text => !string.IsNullOrWhiteSpace(text))
            .SelectAsync(abnLookupService.SearchAsync)
            .AsListFeed(); 
}

The SearchText property is two way data bound to the search TextBox, and the SearchResults feed is derived from the current SearchText value. As the user types in the TextBox, the SearchResults is automatically executed. There are no additional properties required to indicate that the search is in progress.

Note that MVUX makes use of a FeedView in the UI in order to automatically display a progress indicator when the search is being executed.

---

Advantages of MVUX

1. Centralized State

Everything is driven from a single state object. You always know where the source of truth lives, making debugging and testing far easier.

2. Less Boilerplate

No property-changed notifications, no commands to wire up—just pure data and transformations.

3. Predictable UI Behavior

With unidirectional data flow, each action leads to a new state, and the view renders from state. This makes behavior easier to reason about and reduces bugs from hidden bindings.

4. Built-in Side Effect Management

MVUX separates side-effects (like network calls or file I/O) from state logic, making code cleaner and more testable.

5. Better Testability

Reducers are pure functions: given the same input, they always return the same output. This makes unit testing trivial.

---

When Should You Use MVUX?

MVUX is particularly well-suited for:

• Applications with complex UI state or flows.
• Apps where you want strict control and visibility into state changes.
• Teams looking to reduce code complexity and improve maintainability.
• Developers familiar with Redux or functional paradigms.

---

Conclusion

MVVM has served us well, but it shows its age in modern, state-heavy applications. MVUX is a powerful evolution that embraces immutability, functional updates, and unidirectional data flow to make UI development simpler, clearer, and more maintainable.

If you’re tired of verbose ViewModels, hunting down binding errors, or managing a growing list of ICommands, it might be time to rethink your architecture—and give MVUX a try.

---

Resources:

• MVUX in Uno Platform Docs
• MVUX GitHub

The post Stop Using MVVM appeared first on Nick's .NET Travels.

In Azure AI developments, see the new Deep Research in Azure AI Foundry Agent Service for enhanced AI capabilities. Joe Filcik asks: what if you could cut AI costs by 60% without losing quality? - Running through the new cost model for Azure AI Content Understanding. Konstantinos Passadis runs through building an AI Assistant for Microsoft Learn Docs MCP. And, Tim Meyers discusses listening at scale: using Gen AI to understand 10,000 voices.

As we highlighted last week, the new shortcut transformations in Microsoft Fabric allow you to keep data fully in-sync. Here, Miquella de Boer runs through some more concrete examples of usage. You can now Access your Delta Lake tables as Iceberg automatically in OneLake (Preview), and Carmel Eve has recorded a short talk How does Delta Lake work?.

Joseph Guadagno discusses how to simplify your .NET development with Aspire. We used Aspire as part of a recent project and found it incredibly useful for managing development of multi-part solutions. you can learn how to build an AI-powered, unified SOC in a new Microsoft e-book!

And finally, this week I was renewed as a Microsoft MVP for the 10th year in a row. For some reason, I was only renewed under the .NET category and not for Azure, which is slightly puzzling, but ho hum! I'm very pleased to have reached this milestone, and especially as Azure Weekly is heading towards its 11th anniversary in November.

What Is Vibe Coding?

Vibe codingis a new trend in software development where developers use AI tools like ChatGPT or GitHub Copilot to generate code by describing functionality in plain English. Popularized by Andrej Karpathy, vibe coding flips traditional coding:
You describe → AI writes → you tweak → it runs.

“I see stuff, say stuff, run stuff.” – The unofficial motto of vibe coding.

It feels like pair-coding with a genius intern. But in this creative whirlwind of AI-assisted generation, one question remains:
Does unit testing still matter?

---

Why Vibe Coding Is So Popular

Vibe coding is growing fast — for good reason:

• 🚀 Rapid prototyping: Build working code in hours, not days
• 🤖 AI handles boilerplate: Focus on logic, not syntax
• 👶 Accessible for non-experts: Great for juniors and product teams
• 🎯 Flow-state coding: Faster iterations with minimal friction

It feels like playing jazz: expressive, improvised, and powerful.

But here’s the catch: AI can write plausible code — not always correct code.

---

The Risk: Code You Don’t Fully Understand

In vibe coding, you often:

• Don’t write most of the code
• Don’t fully read every generated line
• Don’t test deeply before running

That opens the door to:

• ❌ Hidden logic bugs
• 🔓 Security flaws
• 🧟 Code you can’t maintain or refactor

So how do you keep your AI-generated code safe and reliable?

---

Unit Testing: The Secret Sauce for Safe Vibe Coding

Let’s be clear:
Unit testing doesn’t break the vibe — it protects it.

Here’s why:

✅ 1. Catch Errors the AI Missed

AI doesn’t understand your business rules. Unit tests ensure your code behaves the way it should — even when it looks right syntactically.

🔄 2. Create Fast Feedback Loops

Vibe coding is iterative. So is unit testing.
Write a test → run the AI → test again → repeat.

🔒 3. Refactor with Confidence

If the AI produces spaghetti code, tests give you the confidence to clean it up. You’re free to restructure, knowing your tests have your back.

🧠 4. Understand Behavior, Not Just Code

Tests don’t just validate logic — they document expected behavior, especially useful when you didn’t write the original code.

---

Unit Testing in Vibe Coding with Typemock

Vibe coding thrives when paired with tools that don’t get in your way.

Enter Typemock.

With Typemock Isolator for .NET and Isolator++ for C++, you can:

• 🧪 Mock anything — sealed, static, or legacy code
• ⚙️ Test AI-generated code without refactoring
• 🛠 Use Arrange-Act-Assert style to create readable, robust tests
• 🐧 Now support Linux/GCC 5.4+ and C++14 — native, no wrappers

Whether the code is yours or the AI’s, you can mock, isolate, and test like a pro.

---

How to Integrate Unit Testing into Vibe Coding

Here’s the new vibe‑dev loop:

1. ✍ Prompt the AI to generate a method or class
2. 👀 Skim the output — understand the logic (roughly)
3. 🧪 Write unit tests to define expected behavior
4. 🔁 Ask the AI to revise code based on test feedback
5. ♻️ Repeat until green
6. 🔒 Ship with confidence

That’s not just testing — it’s vibe-safe development.

See why vibe-coding needs more than vibes

---

Final Verdict: Vibe Coding + Unit Testing = Power + Safety

Vibe coding is transforming how we write software. But if you’re only relying on AI and skipping tests, you’re building on sand.

With the right tools — like Typemock — unit testing doesn’t slow the vibe.
It amplifies it.

So vibe on. Just make sure your tests are vibing too.

---

🔧 Ready to vibe safely?

👉 Download Typemock Isolator

Read more:
Vibe Coding Wikipedia
Andrej Karpathy YouTube: Vibe Coding
WSJ: Vibe Coding for Business

The post Does Unit Testing Fit In with AI‑Driven Vibe Coding? appeared first on Typemock.

Jake Knapp and John Zeratsky are the co-creators of the Design Sprint (the famous five-day product innovation process) and authors of the bestselling book Sprint. After decades of working with over 300 startups in the earliest stages, they discovered that most startups fail not because they can’t build, but because they build the wrong thing. The very beginning of a startup is your highest-leverage moment, and most teams waste months or years by skipping a few critical early questions. Jake and John developed the Foundation Sprint to help startups validate ideas and compress months of work into just two days.

What you’ll learn:

1. The step-by-step Foundation Sprint process that compresses three or four months of validation into two days—including templates you can use immediately

2. Why differentiation is the #1 predictor of startup success (with the 2x2 framework that you can use with your team)

3. The three fundamental questions every founder should answer before writing a line of code

4. The “note and vote” technique that eliminates groupthink and gets honest answers from your colleagues

5. The seven “magic lenses” for choosing between multiple product ideas

6. The biggest mistake engineers make when building with AI tools

7. The paradox of speed: why “building nothing first” can get you to product-market fit faster

—

Brought to you by:

Brex—The banking solution for startups: https://www.brex.com/product/business-account?ref_code=bmk_dp_brand1H25_ln_new_fs

Paragon—Ship every SaaS integration your customers want: https://www.useparagon.com/lenny

Coda—The all-in-one collaborative workspace: https://coda.io/lenny

—

Transcript: https://www.lennysnewsletter.com/p/the-foundation-sprint-jake-knapp-and-john-zeratsky

—

Where to find Jake Knapp:

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

• LinkedIn: https://www.linkedin.com/in/jake-knapp/

• Website: https://jakeknapp.com/

—

Where to find John Zeratsky:

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

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

• Website: https://johnzeratsky.com/

—

In this episode, we cover:

(00:00) Introduction to Jake Knapp and John Zeratsky

(04:41) Origins of the Design Sprint

(11:06) The Foundation Sprint process

(14:40) Phase one: The basics

(16:57) Case study: Latchet

(28:50) Phase two: Differentiation

(36:24) The importance of differentiation

(40:15) Thoughts on price differentiation

(43:37) Case study: Mellow

(46:04) Custom differentiators

(49:30) The mini manifesto

(52:02) Phase three: Approach to the project

(54:50) Magic lenses activity

(01:02:39) Prototyping and testing

(01:10:00) Real-world examples and success stories

(01:15:15) Motivation behind The Foundation Sprint

(01:17:15) The outcome of the sprint: The founding hypothesis

(01:19:28) The Design Sprint

(01:28:19) The role of AI in prototyping

(01:36:50) Final thoughts and resources

—

Referenced:

• Introducing the Foundation Sprint: From the creators of the Design Sprint: https://www.lennysnewsletter.com/p/introducing-the-foundation-sprint

• Making time for what matters | Jake Knapp and John Zeratsky (authors of Sprint and Make Time, co-founders of Character Capital): https://www.lennysnewsletter.com/p/making-time-for-what-matters-jake

• Eli Blee-Goldman on LinkedIn: https://www.linkedin.com/in/eli-blee-goldman/

• Character Capital: https://www.character.vc/

• Character Labs: https://www.character.vc/labs

• Etsy: https://www.etsy.com/

• Shopify: https://www.shopify.com/

• Naming expert shares the process behind creating billion-dollar brand names like Azure, Vercel, Windsurf, Sonos, Blackberry, and Impossible Burger | David Placek (Lexicon Branding): https://www.lennysnewsletter.com/p/naming-expert-david-placek

• Sonos: https://www.sonos.com/

• Vercel: https://vercel.com/

• Windsurf: https://windsurf.com/

• April Dunford on product positioning, segmentation, and optimizing your sales process: https://www.lennysnewsletter.com/p/april-dunford-on-product-positioning

• Positioning: https://www.lennysnewsletter.com/p/positioning

• 10 things we know to be true: https://about.google/company-info/philosophy/

• Gandalf: https://en.wikipedia.org/wiki/Gandalf

• Frodo: https://en.wikipedia.org/wiki/Frodo_Baggins

• Mordor: https://en.wikipedia.org/wiki/Mordor

• 35 years of product design wisdom from Apple, Disney, Pinterest, and beyond | Bob Baxley: https://www.lennysnewsletter.com/p/35-years-of-product-design-wisdom-bob-baxley

• The Primal Mark: How the Beginning Shapes the End in the Development of Creative Ideas: https://www.gsb.stanford.edu/faculty-research/publications/primal-mark-how-beginning-shapes-end-development-creative-ideas

• Base44: https://base44.com/

• Solo founder, $80M exit, 6 months: The Base44 bootstrapped startup success story | Maor Shlomo: https://www.lennysnewsletter.com/p/the-base44-bootstrapped-startup-success-story-maor-shlomo

• Google Meet: https://meet.google.com/

• Blue Bottle Coffee: https://bluebottlecoffee.com

• Reclaim: https://reclaim.ai/

• The official Foundation Sprint + Design Sprint template: https://www.character.vc/miro-template

• Rippling: https://www.rippling.com/

• Latchet: https://latchet.com/

• Mellow: http://getmellow.com/

• AxionOrbital: https://axionorbital.space/

—

Recommended books:

• Sprint: How to Solve Big Problems and Test New Ideas in Just Five Days: https://www.amazon.com/Sprint-audiobook/dp/B019R2DQIY

• Make Time: How to Focus on What Matters Every Day: https://www.amazon.com/Make-Time-Focus-Matters-Every/dp/0525572422

• Click: How to Make What People Want: https://www.amazon.com/Click-Make-What-People-Want/dp/1668072114

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.

To hear more, visit www.lennysnewsletter.com



Download audio: https://api.substack.com/feed/podcast/167485876/413e92e34e5df23b9613148c5bdf76f4.mp3