Blue Blazes

In this episode, host Jonathan “J.” Tower sat down with Eric Boyd, founder and CEO of responsiveX and a Microsoft Regional Director and MVP, to talk about GitHub’s Spec Kit. Eric argues that a coding agent is a next-token predictor, so every blank you leave in your intent gets filled with whatever is most popular. Spec Kit is an answer to that, and he walks us through how to use it.If you’ve been vibe coding and want a process you can repeat, this episode is for you.Guest Bio:Eric Boyd is the founder and CEO of responsiveX, a Microsoft partner and digital innovation consultancy. He is a Microsoft Regional Director, a Microsoft Azure MVP, and a Microsoft Foundry (AI) MVP with nearly 30 years in the industry. He speaks regularly on Spec Kit and spec-driven development, and on building MCP servers with .NET, including at Beer City Code, where J. first saw the talk that led to this episode.Additional Resources:Spec Kit on GitHub (install instructions and docs): https://github.com/github/spec-kitSpec Driven Development with GitHub Spec Kit (Eric's recorded talk): https://www.youtube.com/watch?v=I7S8nSp7ZnIEric Boyd's website: https://ericboyd.com/responsiveX: https://responsivex.com/

In this episode, host Jonathan "J." Tower sat down with Jeffrey Palermo, CTO and Chairman at Clear Measure, to talk about what changes in software development once AI writes much of the code, and what doesn't. Jeffrey argues this shift is different in kind from the web, agile, mobile, and cloud transitions that came before it, because it changes how we interact with a computer rather than just how we write code. He's equally direct about the limits. A language model is very good at answering questions and has no way to come up with one worth asking, which is the part that still has to come from us.From there, J. and Jeffrey get into why the definition of "good" has to come from outside the model. In practice, that means automated tests as the external standard and builds fast enough to keep pace with how quickly AI now changes code. Jeffrey makes the case that the ten-minute build that felt fast in the DevOps era is now too slow, and that getting down to two minutes means running every stage in parallel rather than in sequence. They also dig into which code is structural and which is decoration (his skyscraper analogy is worth the listen), why Fred Brooks's surgical team is relevant again, and his prediction that the separate IT department is on its way out.If you're trying to work out what software engineering discipline looks like on the other side of AI, this episode is for you.Guest Bio:Jeffrey Palermo is CTO and Chairman at Clear Measure, a software development firm focused on AI-driven delivery for .NET and Azure organizations. He coined the term Onion Architecture in 2008, and it's still one of the most widely referenced ways to structure a long-lived business application. He also hosts the AI DevOps Podcast, formerly The Azure DevOps Podcast, where J. has been a guest more than once. This episode turns the tables.Additional Resources:AI DevOps Podcast, formerly The Azure DevOps Podcast (Jeffrey's show): https://azuredevopspodcast.clear-measure.com/The Onion Architecture, part 1 (Jeffrey's original 2008 post): https://jeffreypalermo.com/2008/07/the-onion-architecture-part-1/Hexagonal / Ports & Adapters Architecture (Alistair Cockburn): https://alistair.cockburn.us/hexagonal-architecture/The Goal by Eliyahu Goldratt (the theory of constraints): https://en.wikipedia.org/wiki/The_Goal_(novel)Toyota Production System by Taiichi Ohno (elimination of waste): https://en.wikipedia.org/wiki/Toyota_Production_SystemThe Mythical Man-Month by Fred Brooks (source of the "surgical team" essay): https://en.wikipedia.org/wiki/The_Mythical_Man-MonthFunction points (the software sizing method Jeffrey points to for estimating): https://en.wikipedia.org/wiki/Function_point

In this episode, host Jonathan "J." Tower sat down with John Waters, fellow partner and founder at Trailhead, to talk about how AI changes every phase of the software development lifecycle (SDLC). Rather than rehashing vibe coding, J. and John walk the full SDLC, including requirements and discovery, design and architecture, implementation, code review, testing and QA, DevOps and deployment, and long-term support. They dig into where AI has helped Trailhead deliver real leverage and where human judgment is still essential.If you're trying to figure out where AI actually fits in real software delivery, besides AI-assisted development, this episode is for you.Guest Bio: John Waters is a Partner and co-founder at Trailhead Technology Partners. A longtime software architect and engineering leader, he's been driving Trailhead's effort to apply AI across the entire software development lifecycle—from discovery and estimation through architecture, implementation, QA, DevOps, and support. This marks his fourth appearance on Blue Blazes, making him the podcast's most frequent guest.Additional Resources:Claude Code: https://www.claude.com/product/claude-codeCodeRabbit (agentic code review): https://www.coderabbit.aiTerraform: https://developer.hashicorp.com/terraformContext7 (up-to-date library/SDK docs for AI): https://context7.comPlaywright (end-to-end testing): https://playwright.devFigma: https://www.figma.comAndrej Karpathy on building knowledge bases / LLM context: https://karpathy.aiTrailhead Technology Partners: https://trailheadtechnology.com

In this episode, host Jonathan “J.” Tower sat down with Spencer Schneidenbach to talk about the practical realities of integrating AI into modern software applications. Rather than focusing on AI hype or novelty chatbots, J. and Spencer dig into what actually makes AI features valuable in production systems and why good AI engineering is still mostly good software engineering.  They cover how to evaluate whether AI is the right solution for a business problem, the difference between AI-assisted development and AI-powered product features, and why many organizations are still misunderstanding what LLMs are actually good at. Spencer also shares lessons learned from production AI implementations, including how his team built systems that evaluate customer service calls using chained LLM workflows.  If you’re trying to separate AI signal from noise, this episode is for you.Guest Bio:Spencer Schneidenbach is an AI Architect, and the President and CTO of Aviron Labs. He has been recognized as a Microsoft MVP for his AI expertise and contributions to the community. You can find him sharing that expertise at events around the world and as a co-host of the new podcast, Agent Driven Development.Additional Resources:Semantic Kernel: https://learn.microsoft.com/semantic-kernel/overview/Microsoft Agent Framework: search “Microsoft Agent Framework” on learn.microsoft.comModel Context Protocol (MCP): https://modelcontextprotocol.ioOllama (local models): https://ollama.comHugging Face: https://huggingface.coAnthropic Engineering Blog: https://www.anthropic.com/engineeringOpenAI Platform Documentation: https://platform.openai.com/docsAviron Labs: https://www.avironlabs.com/

In this episode, host Jonathan "J." Tower sat down with Mike Kistler, Principal Program Manager at Microsoft and one of the maintainers of the official MCP C# SDK, following the SDK's v1.0 release. J. and Mike cover what MCP actually is and how it compares to OpenAPI, why implementing the protocol yourself is harder than it looks, and when to reach for the C# SDK versus the MCP implementations in Azure Functions or API Management. They also dig into the client/host/server architecture, what drove the 1.0 release decision, and how MCP governance evolved from a Discord server with one seat to a Linux Foundation project with a formal spec enhancement proposal process.If you've been building in .NET and wondering whether MCP is something you need to care about, or you've been tinkering and want to understand the production-ready path, this episode will get you there. Guest Bio: Mike Kistler is a Principal Program Manager at Microsoft, where he is one of the core maintainers of the official MCP C# SDK and serves on the MCP steering committee. He is also the PM for SignalR.Additional Resources:- MCP C# SDK documentation: https://csharp.modelcontextprotocol.io- Build your first C# MCP server: search "build your first C# MCP server" on learn.microsoft.com- MCP C# SDK on GitHub: https://github.com/modelcontextprotocol/csharp-sdk- MCP public Discord: modelcontextprotocol.io/community