Announcing Pragmatic AI in .NET Show

If you've spent any time building software in the last couple of years, you've felt the shift. AI coding assistants, agentic workflows, LLM-powered UI — it's not a distant future anymore. It's your pull request queue, your design review, your sprint planning. AI is now part of everyday software development.

But most of what we read about AI in software development is either breathless hype or dismissive cynicism. What's harder to find are honest accounts from developers actually in the trenches — shipping real products, hitting real walls, figuring it out as they go.

That's exactly why we're launching the Pragmatic AI in .NET Show.

Introducing the Pragmatic AI in .NET Show

Each episode will feature developers sharing what and how they're building with AI — the wins, the surprises, and the moments where AI didn't quite do what they expected. We'll dig into the latest developer AI tools, explore agentic workflows, and have frank conversations about where this technology helps and where it still has a way to go.

No hype. No demos that only work in ideal conditions. Just developers talking honestly about what it's like to build software today.

The Developer Landscape Has Genuinely Changed

Let's be honest about where we are. A few years ago, AI in a developer's workflow mostly meant autocomplete that sometimes got lucky. Today, it's something qualitatively different.

AI can now scaffold entire app features, generate test suites, catch bugs during code review, and help developers think through architecture decisions — all before lunch. Tools like GitHub Copilot, Claude Code, Cursor, Codex, and newer agentic frameworks are becoming a real part of how many teams ship software.

But "the landscape has changed" doesn't tell the whole story. The more interesting question is: changed in what ways, for whom, and at what cost?

Here's what we're actually seeing in the .NET community:

• AI tools genuinely accelerate certain kinds of work — boilerplate, CRUD operations, test generation, documentation.
• They also introduce new categories of problems: hallucinated APIs, subtle logic errors that pass code review, and over-reliance on generated code that developers don't fully understand.
• The developers getting the most value aren't treating AI as a replacement for judgment — they're treating it as a highly capable but fallible collaborator.
• And the craft of prompting, reviewing AI output, and integrating it into a real codebase is itself a skill that takes time to develop.

None of this is a reason to stay on the sidelines. But it is a reason to be thoughtful.

The Realities of Building Software with AI

There's a version of the AI narrative: describe what you want, AI builds it, and you ship. If you've tried this on anything beyond a toy project, you know it's more complicated than that.

The reality is messier and more interesting. AI can dramatically speed up parts of your workflow while introducing friction in others. It works best when developers have clarity on what is being built — AI can amplify intent, for better or worse. A vague prompt yields vague code.

Agentic workflows — where AI doesn't just respond to individual prompts but takes sequences of actions toward a goal — are genuinely exciting and genuinely tricky. Getting an agent to reliably navigate a real codebase, understand conventions, and make changes that don't break things downstream is an active area of work, not a solved problem.

We want to build a space where developers can talk honestly about all of this. Where's the leverage? Where are the landmines? What does it actually look like to integrate AI into a professional .NET development workflow?

What We'll Cover

Each episode of the Pragmatic AI in .NET Show will dig into:

• Real developer stories — folks building actual products, not demo apps.
• The latest in developer AI tools — what's new, what's worth attention, and honest assessments of what's still rough around the edges.
• Agentic workflows — practical exploration of autonomous AI patterns and where they fit in a .NET context.
• The meta-skills — prompting, reviewing, integrating, and knowing when not to use AI.

We're intentionally keeping the format conversational. This isn't a polished tutorial series. It's more like pulling up a chair with developers who are figuring this out alongside you.

Why This Matters for the .NET Community

The .NET ecosystem is in an interesting moment. C#/.NET and the broader Microsoft stack have always attracted developers who care about building things that work — reliably, at scale, over time. That ethos doesn't go out the window just because AI is in the picture.

If anything, it makes the conversation more important. How do you maintain code quality when a significant chunk of your codebase is AI-generated? How do you onboard new developers when your workflows have changed? How do you make good architectural decisions when AI can scaffold almost anything?

These are the conversations we want to have. And we think the .NET community — pragmatic by nature — is exactly the right place to have them.

At Uno Platform, we spend a lot of time thinking about how to make cross-platform .NET development faster and more accessible. AI tools are a big part of that picture — MCP tools that give AI "eyes and hands" for app interactivity, smarter design-to-code workflows, and AI-assisted debugging. Good tooling and good judgment work together.

Join Us On The Show

The Pragmatic AI in .NET Show kicks off this Thursday at 11 AM ET. We'd love to have you there.

Whether you're already deep in AI-powered workflows or just starting to explore what's possible, there's something in this for you. Come for the developer stories. Stay for the honest conversation about what building software actually looks like right now.

First Three Guests

See you on the show.