Skip to content
Artwork for Merge Conflict
TechnologyNewsTech NewsEducationHow To

Merge Conflict

soundbite.fm

Merge Conflict is a weekly discussion with Frank and James on all things development, technology, & more. After years of being friends, Frank and James finally decided to sit down and start a podcast about their lives as mobile developers using C#, Xamarin, and .NET MAUI. Much more than just another mobile development podcast, Merge Conflict, reaches all areas of development including desktop, server, and of course mobile. They also cover fun things happening in the world of technology and gaming and whatever else happens to be on Frank's and James' minds.

Play
  • 32 episodes
  • weekly
  • Avg 46 min
  • English

Support the show

Goes straight to the publisher. podnod takes nothing.

Counted on this page — what you have heard stays on this device, so it is not something the list can be paged by.
  • Monday · 53 min

    539: Everything from GitHub Universe 2026

    GitHub Universe’s big theme is bringing AI agents under one roof: James and Frank unpack a shared Copilot harness, sessions that sync across devices and cloud workspaces, and Fusion’s model orchestration. They also weigh practical updates—from connectors and automated code review to projects and agent memory—while sharing where the new tools shine, and where the rough edges remain.

    • Transcript
    • Chapters
  • October 26 · 56 min

    538: AI Agents Rebuild My 13-Year-Old Blog

    James shares how Copilot CLI helped rebuild 13 years of blog posts as a faster, customizable static site—and how AI can turn spoken ideas into polished posts and launch videos. Along the way, the hosts cover new iOS/Xcode requirements, Frank’s ambitious iCircuit update, and practical ways to guide agents with clear assets, constraints, and personal style.

    • Transcript
    • Chapters
  • October 19 · 57 min

    537: Going ULTRA with RTX Spark and New Surface Devices

    Microsoft’s new Surface Laptop Ultra pairs an ARM chip with NVIDIA RTX graphics and unified memory, promising workstation-class power for creators and local AI—at a premium price. The conversation explores why CUDA support and Windows ML matter, how local and cloud models can work together, and how Microsoft’s new container-based isolation aims to keep autonomous coding agents safer. A look at ambitious hardware and the software ecosystem needed to make it useful.

    • Transcript
    • Chapters
  • October 12 · 39 min

    536: Decisions, Microsoft-Decision-1, Decisions

    This week we look at decision models, which have gone from a novelty to something every AI lab is now building. We start with a practical detour: where do you actually sell a high-end Mac mini these days? We compare local marketplaces and eBay, and the trust tradeoffs that come with each. Then we come back to decision models and explain why Jev got us interested in them again. We cover Microsoft's Decision One and what makes it notable: its benchmarks and its speed. We also walk through how deci

    • Transcript
    • Chapters
  • October 5 · 46 min

    535: Next-Gen Siri: Disappointingly Not the Chatbot We Wanted

    James and Frank explore Apple's next-gen Siri and iOS 27 updates with mixed results—the chatbot fell short of expectations despite hype. They dive into AI agents, smart home automation potential, and why Apple's scattered AI integration lags behind competitors like OpenAI and Microsoft. Plus, practical developer updates on Xcode, .NET, and automating your digital life.

    • Transcript
    • Chapters
  • September 28 · 40 min

    534: Why Developers Are Obsessed with Budget LLMs (Jev, Luna, & more)

    Discover the emerging classifier revolution with Jev—a radical new take on LLMs that ditches generation for lightning-fast categorization. Plus, deep dives into the latest model releases (Luna, GPT-6 Sol, Claude Opus 5.5), practical strategies for iterative AI development, and why specialized models are reshaping how we work with AI.

    • Transcript
    • Chapters
  • September 21 · 45 min

    533: iPhone Duo Development: Navigating Dual Screens and Layouts

    Apple's new iPhone Duo promises a game-changing foldable experience, but developers face a minefield of technical challenges. James and Frank break down the critical app adaptation work required—from handling multiple screen permutations to managing safe area insets and keyboard behavior—plus why native UI controls matter more than ever. 

    • Transcript
    • Chapters
  • September 14 · 42 min

    532: HydraFusion: Multi-Model Orchestration Changes Everything

    Discover how multi-model orchestration is revolutionizing AI development. James and Frank explore strategic use of reasoning levels with smaller models—achieving 90-95% cost savings without sacrificing quality—and introduce Hydrofusion, GitHub's game-changing runtime that intelligently routes tasks across models. Learn how to build enterprise-grade features asynchronously while slashing your AI token bills.

    • Transcript
    • Chapters
  • September 7 · 37 min

    531: How AI Saved Our Lost Podcast Recording

    In Episode 531 James and Frank recount a near‑disastrous data loss when local recordings died seven minutes in, forcing them to rely on Zencastr's cloud-recovery button and a hopeful rescue email. They walk through the panic and the clever fix—using GitHub Copilot CLI/Baby Luna, FFmpeg and AI-assisted workflows to rebuild a muxed video, repair audio‑video drift, and underscore lessons about testing restores and trusting backups.

    • Transcript
    • Chapters
  • August 31 · 1 hr 5 min

    530: WinUI Goes Open Source & Mac Mini/Studio Upgrades!

    This episode kicks off with WinUI’s shift to open‑source‑first—what the GitHub‑centric workflow means for Windows devs—and James and Frank’s hands‑on tales modernizing apps, CI/CD, and the surprisingly smooth Microsoft Store pipeline. They then deep‑dive into Apple: M6 Mac mini and Mac Studio upgrades for local AI, Rosetta’s sunset and Intel‑Mac worries, foldable iPhone rumors, and possible Apple TV Thread/HDMI features—practical insights for choosing platforms and tooling.

    • Transcript
  • August 24 · 42 min

    529: Agent, MCP, and Tooling: Taming Cross‑Platform DevFlows

    In this update-packed episode James and Frank dive into developer tooling: the VS Code Mobile Canvas that embeds emulators into your editor, MAUI DevFlow’s rewrite enabling plain .NET/native (and desktop AppKit) support, and the growing MCP/agent ecosystem that ties editors, the Copilot app and CLI together. They share practical takeaways—Mobile Canvas works across frameworks, DevFlow supports non‑MAUI apps, agent instruction files matter, and you can automate Microsoft Store publishing—giving c

    • Transcript
    • Chapters
  • August 17 · 40 min

    528: Build, Ship, Repeat: AI Tools Changing App Development

    In episode 528 James and Frank riff on software updates, AI-powered documentation and rapid app-building—covering a WebAssembly Oh My Posh demo, a LocalMorph/FFmpeg bridge, and MAUI-native builds—showing how AI can speed onboarding, re-theme UIs and generate CI/CD pipelines. They close with a lively debate on distribution—Homebrew vs app stores—sharing practical guidance on when to use package managers versus polished consumer releases, plus a playful detour into Frank’s FIRE calculators.

    • Transcript
    • Chapters
  • August 10 · 50 min

    527: AI Agents Meet Mobile: GitHub Copilot Canvas Revolution

    AI agents are revolutionizing mobile development! James and Frank explore GitHub's new Mobile Canvas extension that lets AI agents see and interact with iOS and Android apps in real-time, no matter what framework you're using. They discuss how this tool finally closes the feedback loop for native developers and break down the emerging plugin standard reshaping AI-assisted coding.

    • Transcript
    • Chapters
  • August 3 · 43 min

    526: GitHub Stacked PRs: Managing Complex Code Changes

    In this episode, James and Frank dive deep into GitHub's biggest release in years: Stacked Pull Requests. Learn how this long-awaited feature finally solves the challenge of managing massive, complex code changes by breaking them into smaller, independently reviewable chunks while maintaining dependencies—plus discover how Merge Queues work alongside this innovation to streamline workflows in high-velocity projects.

    • Transcript
    • Chapters
  • July 27 · 38 min

    525: Why Christopher Nolan's IMAX Vision is Fading

    Frank celebrates his birthday in style at Seattle's IMAX theater—but discovers a disappointing truth: the Pacific Science Center has ditched traditional 70mm film projection for modern digital lasers. Explore why true IMAX experiences are vanishing even as directors like Christopher Nolan continue creating films specifically for this format, and what this means for the future of premium cinema.

    • Transcript
    • Chapters
  • July 20 · 37 min

    524: A .NET MAUI AI Revolution

    On episode 524 James and Frank dive into the new .NET MAUI developer stack—covering the MAUI CLI/Maui Doctor that auto-provisions SDKs and emulators, the Maui Sherpa GUI for device/Xcode/provisioning management, and DevFlow's MCP server that lets AI agents inspect, interact with and automatically test apps (closing the loop). They also highlight the VS Code MAUI agent/skills, profiling tools, and the shift to core CLR in .NET 11 with performance tradeoffs to watch.

    • Transcript
    • Chapters
  • July 13 · 46 min

    523: UI.md - Opinionated design rules for coding agents

    Frank releases UI.md, a practical markdown guide distilled from 25 years of software development that captures essential UI/UX principles to help AI (and developers) build better interfaces. The hosts dive deep into why users expect consistency, how small details create polish, and why understanding your users' mental models beats flashy design every time—with real-world examples from their own apps.

    • Transcript
    • Chapters
  • July 6 · 37 min

    522: Our Thoughts on Slate: The $25K Modular Pickup Changing EVs

    James and Frank dig into Slate’s modular electric pickup — a $24,950, 205‑mile, no-frills truck you can customize later — and unpack how factory vs dealer options, aftermarket mods and build quality will make or break the idea. They also cover real-world charging (level 1/2/3), fleet and daily-use practicality, and why a DIY, upgradeable EV could reshape affordable vehicle ownership.

    • Transcript
    • Chapters
  • June 29 · 48 min

    521: Polish Matters: UI, Icons, and AI Design Fails

    Episode 521 James and Frank obsess over “polish”: the tiny design and packaging details that make apps feel finished. They start with impeccable.style, product.md and design.md (and why agents.md/readme aren’t enough), then dig into UI fit‑and‑finish — tray/menu UIs, icon choice, grouping settings and why AI agents still struggle with layout and whitespace. The conversation then moves deep into Windows packaging: WinApp SDK versions, trimming woes with WinRT, ready‑to‑run vs. single‑file self‑co

    • Transcript
    • Chapters
  • June 22 · 58 min

    520: Inside the New GitHub Copilot App: Sessions, Canvases, Automations

    We dive into the new GitHub Copilot app — from multi‑repo, multi‑session agents and agent‑merging that respects CI/PR flows, to Canvases for visual triage and Automations (cron‑style agent workflows) — and what that means for real‑world dev productivity. Plus James and Frank share hands‑on notes on WinUI native apps, packaging to WinGet, and practical tips for debugging and shipping cross‑platform tools.

    • Transcript
    • Chapters
Showing 1–20 of 32 episodes