Microsoft's New AI Workflow Builds and Publishes WinUI 3 Apps in About 30 Minutes Using VS Code and CLI

Microsoft has published an official quickstart for a development workflow that lets developers build, test, and publish applications using "WinUI 3," the native UI framework for Windows 11, in about 30 minutes—without ever opening Visual Studio. Until now, serious native Windows development typically began with a major hurdle: installing tens of gigabytes of Visual Studio and wrestling with complex project configuration. This new workflow instead centers on Visual Studio Code (VS Code), the .NET SDK 10, and a command-line tool called "winapp CLI," offering a path that relies entirely on free tools plus AI assistance.

What stands out in this new setup is not just the combination of lightweight tools, but a deliberate fix for a structural problem that has long plagued AI coding assistance: the tendency to generate outdated code. To prevent generative AI from mistakenly suggesting legacy UWP (Universal Windows Platform) APIs, Microsoft has built a dedicated plugin called "winui-dev" and an MCP (Model Context Protocol) server that fetches the latest documentation in real time directly into the standard toolchain. At a moment when web-technology-based wrapper apps like Electron are drawing criticism for their heavy memory footprint, Microsoft is moving to sharply lower the barrier to entry for native Windows app development by streamlining the developer experience and integrating AI support.

Why VS Code and the CLI Are Enough on Their Own

Traditional Windows desktop development—particularly with the Windows App SDK and WinUI 3—required numerous setup steps: selecting Visual Studio workloads, configuring MSIX packaging, managing certificates, and more. The new workflow consolidates all of this complexity into the open-source "winapp CLI" (Microsoft.winappcli) and standard features built into .NET SDK 10 and later.

Developers can create a WinUI 3 project complete with navigation structure simply by running a scaffolding command in the terminal.

mkdir MyFirstApp
cd MyFirstApp
dotnet new winui-navview
dotnet run

Running dotnet run launches the app instantly in a development-friendly "loose layout" format, skipping the full MSIX package installation. This eliminates the build and install wait times that used to precede debugging, offering a rhythm of iteration nearly as fast as web frontend development.

VS Code also now has an official "WinApp extension" (microsoft-winappcli.winapp). From the command palette, developers can invoke "WinApp: Run Application" or "WinApp: Create MSIX Package" to handle package ID assignment and builds without ever leaving the editor.

Packaging for distribution has also been folded into the CLI. Running the following command in an administrator terminal automatically generates and installs a self-signed test certificate for local testing and outputs a distributable MSIX file.

dotnet publish -o ./publish
winapp pack ./publish --generate-cert --install-cert

Submitting to the Microsoft Store is just as streamlined: with a Partner Center account, a single command—winapp store publish ./*.msix --appId —sends the package from the terminal. Review still typically takes one to three business days, but the pipeline from project creation to store submission is now a straight line through the CLI.

The Trap of AI-Generated Legacy UWP Code, and the Role of Specialized Agents

Even as the tooling gets lighter, handing code generation over to AI still carries a Windows-specific pitfall. Large language models (LLMs) have been trained on more than a decade's worth of UWP and WPF code and Q&A site answers. WinUI 3, built on the Windows App SDK, is a comparatively new framework by contrast. As a result, if you ask a general-purpose AI agent to "build a Windows app screen," it will very likely output deprecated UWP classes and namespaces.

To address this, Microsoft offers a dedicated plugin called "winui-dev" for GitHub Copilot CLI and Claude Code.

This plugin injects the API rules shown above directly into the AI as system-level custom instructions. As a result, developers no longer need to remind the AI in every single prompt to "use WinUI 3 APIs, not UWP."

Winui-dev is not just a single collection of prompts—it packages eight specialized skills tailored to different stages of development.

1. winui-setup: Verifies and configures prerequisites such as the .NET SDK, winapp CLI, templates, and Developer Mode.
2. winui-dev-workflow: Guides the cycle from scaffolding through building, running, and iterative fixes.
3. winui-design: Generates XAML layouts that comply with Fluent Design and selects controls backed by references such as the WinUI Gallery.
4. winui-code-review: Evaluates whether generated code follows WinUI 3 conventions and checks for anti-patterns.
5. winui-ui-testing: Uses Windows UI Automation to generate automated UI tests based on the accessibility tree.
6. winui-packaging: Assists with MSIX packaging, signing, and store submission.
7. winui-wpf-migration: Provides API mappings for migrating existing WPF code to WinUI 3.
8. winui-session-report: Summarizes what was built during a work session and proposes the next implementation steps.

By assembling a framework in which AI autonomously writes code, reviews it, and even builds UI tests, Microsoft aims to let engineers with little Windows development experience proceed without hitting dead ends.

Real-Time Spec Lookups via the Learn MCP Server

Another key mechanism that avoids relying solely on a model's pretrained knowledge is the standard adoption of the "Microsoft Learn MCP server."

MCP (Model Context Protocol) is an open protocol that lets AI agents call external tools and data sources through a standardized interface. Microsoft has made a public MCP endpoint (https://learn.microsoft.com/api/mcp) available that can search and retrieve content from the official Microsoft Learn documentation site. No authentication or API key registration is required—developers simply add the URL to their VS Code (GitHub Copilot) or Claude Code configuration file to connect.

{
  "servers": {
    "microsoft-learn": {
      "type": "http",
      "url": "https://learn.microsoft.com/api/mcp"
    }
  }
}

With this server connected, the AI agent searches Microsoft Learn's latest API reference right before generating code, confirming the correct signature before producing an implementation.

For example, when implementing a file selection dialog (FileOpenPicker), the old UWP code didn't require explicit window handle initialization. But in WinUI 3, which runs as a desktop app, failing to explicitly associate a window handle (HWND) will throw an exception. With the MCP server connected, the AI pulls the current best practice—that it must call WinRT.Interop.InitializeWithWindow.Initialize—straight from the official documentation and produces accurate code. By giving AI a way to look up current specifications on the fly, Microsoft curbs build errors caused by API obsolescence and hallucination.

How Realistic Is a Native Comeback, and What Limitations Remain

Microsoft's urgency in refining such a lightweight, AI-friendly development experience is rooted in the rise of web technology in the desktop app market. From Slack and Discord to VS Code itself, many modern desktop apps run on Electron or WebView2, which bundle Chromium and Node.js. While this offers the convenience of reusing existing web assets, it has long drawn criticism for consuming tens to hundreds of megabytes of memory per app, straining battery life and startup speed.

WinUI 3, by contrast, taps directly into Windows 11's native controls and DirectX rendering engine, giving it an edge in memory efficiency and responsiveness. But until now, the barrier of having to launch Visual Studio and configure a heavyweight project has discouraged web-focused engineers from choosing native development. This new workflow aims to combine the command line, a lightweight editor, and AI agents to make building native apps just as easy as web frontend development.

That said, Visual Studio hasn't become entirely unnecessary. For real-time inspection of complex XAML visual trees, advanced memory leak profiling, or sophisticated debugging involving mixed C++ and C# code, Visual Studio's IDE environment still holds an advantage. The WinApp extension and related tools also remain in preview, meaning their specifications and command structures may still change.

The question now is how far this new path—quickly spinning up the skeleton of a working native app with VS Code and AI, then shipping it to the store as needed—can cut into a desktop landscape still dominated by heavyweight web wrapper apps.