These past two weeks have been some of the most exciting days I’ve had as a developer. I need to commemorate them.

The shift I'm seeing is simple but profound: when Copilot can run the app, see the UI/DOM, and read logs and screenshots without me babysitting it, iteration speed stops being linear. It feels like years of work compressing into days.

Here’s the haul so far:

• MAUI Sherpa
• MauiDevFlow
• PolyPilot
• .NET MAUI Terminal
• .NET MAUI Linux
• .NET MAUI macOS and tvOS
• .NET MAUI Bootstrap Themes
• .NET MAUI Skills

The common thread here is simple: once Copilot can run the app, inspect UI/DOM, and read logs/screenshots without me babysitting it, iteration speed goes nonlinear. Below is the proof and it's B-A-N-A-N-A-S!

MAUI Sherpa

MAUI Sherpa is a Blazor Hybrid app that puts a face to a set of CLI tools for managing your Android and iOS developer environment. That includes SDKs, Devices, Simulators, Emulators, keystores, certificates, provisioning profiles, and so much more.

Managing your environment, installing the right things, knowing what is even installed, and then handling all the certs and provisioning can be among the most frustrating aspect of cross-platform development. This app makes it much easier for you.

Jon Dick built this app in just a few hours, and the key thing he did here that blew my mind involved his new tool MauiDevFlow which essentially gave eyes and hands to Copilot so it could work uninterrupted to build and validate the app. In very short order this app was built, beautiful, and shipped.

MauiDevFlow

This CLI tool builds upon the Apple and Android tools Jon built over the years for Xamarin and .NET MAUI (and Avalonia and Uno). Onto it he added all the things we have been bolting onto our Copilot experiences to help Copilot do more for .NET MAUI projects without needing our intervention.

Features include:

• App automation - it can see the UI tree, tap, type, interact, swipe, scroll, and all the things plus screenshot
• BlazorWebView debugging - doesn't just stop at the native elements, but goes deep in the DOM and JS
• Unified logging - quit asking me what the error is and to paste it into the session! Copilot can read for itself.
• Port broker to work with multiple apps simultaneously
• CLI tool for calling commands to automate all the things
• Driver Library for platform specific orchestration
• Skills! to superpower Copilot (and Claude)

The skill will install a NuGet in your project, wire up the host builder to create hooks needed, and you're all set. Kick back and watch Copilot got fully autonomous at your command.

PolyPilot

PolyPilot assists you in orchestrating as many Copilot sessions as your tokens and terminals will allow from a beautiful dashboard, but that's just the start.

Shane Neuville at the time of this writing ranks among the heaviest users of Copilot in all of Microsoft, and his creation PolyPilot is a big reason why.

This week the MAUI team has gone wild evolving PolyPilot and crushing work at the same time. It has been one of the most invigorating team experiences I've ever had!

The secret sauce is that PolyPilot helps you work on PolyPilot while you use PolyPilot. See something you want to improve or change? Do it. PolyPilot will do the work, rebuild, and reload the app in flight. It has all the observability we just talked about with MauiDevFlow and so much more.

You've got 5 sessions running on different tasks and want to step away? No sweat. PolyPilot is on your phone too, participating over a devtunnel (and recently added direct connection on your LAN).

Tell PolyPilot what you need from the couch, the dinner table, the...um, gym.

And the same self improvement loop works here too. PolyPilot can build and deploy the mobile app and refresh you on the fly. It's completely intoxicating the feeling of productivity and power I get.

.NET MAUI Terminal

MAUI.TUI is a terminal UI backend for .NET MAUI. Of minimal value in practical use, this experiment demonstrates how well (and quickly) Copilot can build a fresh backend for .NET MAUI.

If you're unfamiliar with this use of "backend", .NET MAUI backend is the rendering/input implementation for a platform: UIKit for iOS, WinUI for Windows, etc.

.NET MAUI Linux

With Maui.TUI showing the way, Jon set his sights on Linux. In short order he produced a very functional Linux backend with GTK4.

You can try it today! Instructions are on the repository below.

.NET MAUI macOS and tvOS

Not to be left out, Allan Ritchie took the challenge from Jon to do the same for adding a macOS backend with AppKit to .NET MAUI. Today .NET MAUI's official backend for macOS is Mac Catalyst, which looks great and works well for most use cases, but occasionally you may want a more pure desktop SDK.

Allan and Jon discuss and demo their projects in this week's GoneDotNet podcast which you should absolutely watch.

src/
  Microsoft.Maui.Platform.TvOS/     # tvOS backend library (net10.0-tvos)
  Microsoft.Maui.Platform.MacOS/    # macOS AppKit backend library (net10.0-macos)
  Microsoft.Maui.Essentials.TvOS/   # tvOS Essentials library
  Microsoft.Maui.Essentials.MacOS/  # macOS Essentials library
samples/
  Sample/                           # Shared sample code (App.cs, MainPage.cs, Platforms/)
  SampleTv/                         # tvOS sample app (links files from Sample/)
  SampleMac/                        # macOS sample app (links files from Sample/)

.NET MAUI Bootstrap Themes

This library will let you drop any Bootstrap css into your .NET MAUI resources and wire it in as your app theme over native controls.

This is a bit of a 2-for-1 story. Inspired by the productivity Jon and Shane were having with Blazor Hybrid in Sherpa and PolyPilot, I chose to try porting my language learning app Sentence Studio from native controls to Blazor Hybrid.

Native controls

With the combination of the maui-ai-debugging skill that uses MauiDevFlow in Copilot CLI (yes, I did yolo it), this conversion only took a few minutes to get to a usable stable, and then some polish and improvements over the course of a few days. When you give Copilot eyes and hands to be able to validate its own work and keep the forward progress going, it's next level stuff.

Blazor Hybrid with Bootstrap

Everything just looks so polished with minimal effort. And I can swap to any theme in an instant. Making the UI look and feel more natural on mobile was also not hard at all.

Then I thought, "wouldn't it be cool to have the same styling for .NET MAUI native controls and layouts?" This isn't crazy to pursue, it's just that .NET lacks the same deep commitment to a singular way of theme and styling as web does with Bootstrap.

In London last week Matt Goldman showed his library Flagstone-UI which provides a couple of controls that support Bootstrap styling tokens. This is the common way I've seen this done: .NET MAUI controls don't support all the styling properties that Bootstrap expects and so you need to create a custom control. Why? Because amending and extending handlers across all the platforms can be time consuming and complex.

But what was hard in the past is just a few minutes of Copilot time now. The thing that was hours of research and days of trial and error is now just minutes of Copilot time. Nothing is beyond your reach.

So here is the first iteration of .NET MAUI Bootstrap Theme support over native controls with no custom controls used.

dotnet add package Plugin.Maui.BootstrapAdapter

.NET MAUI Skills

Ever since skills reached Copilot the results I'm getting are substantially better. These are what I wanted Copilot instruction prompts to be so many months ago. Load up useful skills and if Copilot is being diligent it will use them when the right words are spoken. In addition to detailed information, code snippets, and prompt instructions, a skill can include executable code like shell scripts, python scripts, etc.

My first attempt at a skill was maui-speech-to-text which does exactly what it says. I tested it on several apps including my Barista Notes app where I instructed Copilot to enable any user to speak to the app and do anything the app can do.

This worked so well, so consistently I wondered what more I should put into a skill.

Where is the best knowledge about .NET MAUI on the internet? Microsoft Learn, of course. So I pointed Copilot at Learn with a skill to create skills and the result is davidortinau/maui-skills, a set of 34 skills and growing to help you with .NET MAUI development tasks like adding local and push notifications, Aspire, authentication, and more.

How to replicate this

Here's what I would recommend everyone do:

• Install MAUI Sherpa and run doctor on your environment
• Use MauiDevFlow with Copilot to close the loop
• Install maui-skills to sharpen Copilot's solutions
• Multiply this by adding PolyPilot

My current rules are to keep the tasks simple and understood, make sure to keep the loop closed empowering Copilot to solve issues on its own, and be explicit about exit criteria.

Celebration

We didn’t get here overnight—and this week reminded me it’s never just one person. It’s the tools, the skills, the feedback loops, and a team willing to push them until they click.

Yes, it’s tokens and models and prompts. But the real unlock is removing the constant “pause and explain” tax. Once the loop closes (build, run, observe, tweak) progress compounds fast.

If you haven’t felt the “five years in two weeks” thing yet, I get it. I’ve watched other people describe it and wondered what I was missing. For me, the difference was going further, for longer, with better instrumentation. And when it lands… it’s honestly hard to go back.