
Sign up to save your podcasts
Or


Software has traditionally been built around a familiar model: identify a market, define a product, assemble a development team, build the application, and sell it to many customers.
But what happens when AI dramatically lowers the cost of creating software?
Could we move toward a world where software is built specifically for one customer but produced through a repeatable, scalable process?
In this episode of Tech Council, Duncan Mapes talks with returning guest Jason McMunn about Oasis and the concept of an AI software factory.
Rather than thinking about AI as simply another developer tool, they explore what happens when AI becomes part of an end-to-end system for producing software. The discussion covers everything from customer interviews and personas to journeys, AI model selection, infrastructure automation, cost management, deployment, and observability.
One of the most interesting ideas is the concept of SaaS for a customer of one. Traditionally, software economics depend on spreading development costs across many customers. But AI could change that equation by making highly customized software economically viable.
That creates a very different set of questions.
How do you standardize the parts of development that can be standardized? Where does human judgment remain essential? When should a company use a powerful commercial AI model versus an open-source alternative? And how do you build infrastructure that can support an expanding number of AI-powered applications without allowing costs to spiral?
The conversation also looks beyond development itself. An AI software factory touches the entire software lifecycle, from understanding what a customer actually needs to operating the finished system in production.
For engineering leaders, technology executives, entrepreneurs, and anyone trying to understand where AI is taking software development, this episode offers a practical look at a model that could fundamentally change the economics of building software.
Top Takeaways:
Connect with our Guest:
Jason McMunn - https://www.linkedin.com/in/mcmunn
Connect with us:
Duncan Mapes
DevGrid.io
DevGrid on LinkedIn
DevGrid on X
The impact of AI on software development is often measured in lines of code, developer productivity, and the ability to automate repetitive tasks. But those measures only capture part of the transformation.
In this episode of Tech Council, Duncan Mapes, Micah Minarik, and Bill Clerici examine the broader organizational implications of AI in software development.
Their discussion explores three interconnected areas: software delivery, organizational structure, and technology careers.
First, the episode considers how AI is affecting the software development lifecycle. As AI-assisted development changes how quickly teams can produce and modify software, organizations may need to reconsider assumptions about development workflows, productivity, and delivery.
Second, AI creates organizational questions. If individual developers become more productive, do teams need to become smaller? Does the role of engineering management change? How should organizations balance increased development speed with quality, maintainability, security, and accountability?
Finally, the conversation examines what these changes mean for people entering software development. The traditional career ladder has often relied on junior engineers gradually building experience through increasingly complex technical work. If AI can perform some of that work, organizations and individuals may need to rethink how technical expertise is developed.
The discussion also puts today's AI transformation into historical context by looking at the evolution of Agile and modern software development practices.
The central question isn't simply whether AI will change software development. It already is. The bigger question is how organizations and engineers choose to adapt.
Top Takeaways:
Connect with Our Guests:
Micah Minarik - https://www.linkedin.com/in/micahminarik/
Bill Clerici - https://www.linkedin.com/in/bill-clerici-16a3194/
Connect with us:
Duncan Mapes
DevGrid.io
DevGrid on LinkedIn
DevGrid on X
Everyone says AI is making software development easier.
That’s only partially true.
While AI accelerates the act of writing code, it also amplifies existing problems. Poor inputs produce poor outputs faster. Weak specifications lead to larger-scale inefficiencies. And teams that prioritize speed without clarity often end up with more rework, not less.
This episode challenges the idea that AI is purely a productivity multiplier. Instead, it explores how AI is exposing deeper issues in how software is planned, validated, and maintained.
AI is unlocking new capabilities, but it’s also introducing new complexity that teams must learn to manage.
Top Takeaways:
Connect with us:
Duncan Mapes
DevGrid.io
DevGrid on LinkedIn
DevGrid on X
The future of enterprise development will be defined by systems that can adapt, analyze, and respond in real time.
That future requires infrastructure designed for AI.
In this episode, Duncan Mapes and Jason Ehmke explore how DevGrid is building that infrastructure through its MCP server.
The conversation examines how DevGrid connects enterprise software ecosystems through an AI-native graph that allows systems to share context, detect issues, and surface insights across development and operations.
Key topics include secure authentication models, asynchronous data processing, vulnerability detection, and strategies for reducing friction across enterprise engineering teams.
As organizations continue integrating AI into their workflows, platforms like DevGrid will play an increasingly critical role in enabling secure, scalable, and intelligent enterprise development environments.
Top Takeaways:
Connect with us:
Duncan Mapes
DevGrid.io
DevGrid on LinkedIn
DevGrid on X
AI adoption is accelerating across industries, but scaling AI successfully remains one of the hardest leadership challenges today.
In this episode of Tech Council, we speak with Jason McMunn about what leaders must get right when implementing AI across large organizations. Moving from experimentation to enterprise-wide AI deployment requires more than enthusiasm for new tools. It demands alignment across people, process, and governance.
Jason explains how AI reshapes the way engineering teams operate, how decision-making evolves when intelligence is embedded into workflows, and why upskilling is now a strategic priority rather than a technical afterthought. AI introduces new efficiencies, but it also exposes weak organizational foundations. Without trust and clarity, even the most advanced AI initiatives stall.
This conversation provides a grounded perspective on enterprise AI transformation. It moves beyond hype and focuses on execution, leadership responsibility, and long-term sustainability. For executives navigating AI adoption, this episode offers practical insight into scaling AI with intention.
Top Takeaways:
Connect with us:
Duncan Mapes
DevGrid.io
DevGrid on LinkedIn
DevGrid on X
Software development used to begin with local setup headaches, dependency mismatches, and “it works on my machine.” Now, the environment spins up in the cloud. The editor follows you. The assistant writes alongside you.
In this episode, Duncan Mapes and Jason Ehmke explore what tools like GitHub Codespaces and Codex really mean for the future of software development not just in terms of speed, but also in terms of responsibility.
They unpack how velocity is shifting when AI can generate code instantly, how developers are rethinking environment management, and why craftsmanship looks different in a world where automation handles the mechanics. But they also wrestle with the hard questions: What happens to velocity measurement? How do teams maintain quality? Where does human judgment matter most?
More than getting faster, software development is becoming structurally different. AI changes the relationship between engineers, tooling, QA, and production.
The real question isn’t whether to adopt these tools. It’s whether your organization understands the second-order effects of adopting them.
Top Takeaways:
Connect with us:
Duncan Mapes
DevGrid.io
DevGrid on LinkedIn
DevGrid on X
Metrics influence outcomes by shaping incentives.
When engineering metrics are poorly designed, they encourage short-term optimization, suppress risk-taking, and mask systemic issues like technical debt and security gaps. When designed well, they provide early signals, enable informed trade-offs, and reinforce cultural norms.
In this episode, Tech Council breaks down the mechanics of effective metrics: defining standards, ensuring visibility across applications, and understanding the economic implications of compliance and security. Duncan and Jason analyze how leadership behavior amplifies the impact of metrics, and why transparency determines whether metrics motivate or demoralize engineering teams.
Top Takeaways:
Connect with us:
Duncan Mapes
DevGrid.io
DevGrid on LinkedIn
DevGrid on X
AI has changed the conversation in software development, but not in the way most people expected.
While much of the industry focuses on speed, this episode of Tech Council explores the deeper shift: AI is changing how software is built. Faster feedback loops demand better decision-making. Automated workflows raise the bar for testing, rollout strategies, and system resilience.
Duncan Mapes and Jason Ehmke examine why feature flags, automation, and thoughtful development practices are no longer optional when AI accelerates delivery. It also addresses the cultural shift required as engineers adapt to new responsibilities in an increasingly automated environment.
Rather than framing AI as a shortcut, this episode positions it as a forcing function, one that exposes weak processes and rewards teams that prioritize clarity, quality, and customer insight.
Top Takeaways:
Connect with us:
Duncan Mapes
DevGrid.io
DevGrid on LinkedIn
DevGrid on X
When engineering teams talk about observability, they often picture dashboards, alerts, and vendor slides. But inside real enterprise systems, observability is a story about people. It’s about how they communicate, how they respond under pressure, and how they collaborate when platforms are messy, duplicated, or half-maintained.
In this episode, Duncan Mapes and Jason Ehmke sit down with platform veteran Jason McMunn, who has spent years untangling observability chaos across large organizations. What unfolds is a candid look at what actually breaks when systems scale, fractured ownership, unclear contracts between teams, and the silent cost of tools nobody fully uses.
Through real incidents, leadership lessons, and platform consolidation stories, the trio walks through what it looks like to build observability that teams trust, not just observability that vendors promise. If you’ve ever shipped an alerting strategy that blew up in your face, wrestled with tool sprawl, or tried to rebuild trust between teams after an outage, this is the guide you’ve been needing.
Top Takeaways:
Connect with us:
Duncan Mapes
DevGrid.io
DevGrid on LinkedIn
DevGrid on X
Viewed through the lens of systems thinking, AI introduces both leverage and fragility into the development lifecycle. In this episode, Duncan Mapes, Jason Ehmke, and returning guest, Chris Boyd break down how AI affects feedback loops, failure modes, team throughput, and the architecture of modern systems.
They explore the evolving responsibilities of engineers in an environment where code generation is partially automated, and discuss how AI reshapes design principles, mobile development approaches, and cross-team dynamics.
The takeaway: AI is neither a panacea nor a threat. It’s a force multiplier for teams who know how to use it, and a risk amplifier for those who don’t.
Top Takeaways:
Connect with us:
Duncan Mapes
DevGrid.io
DevGrid on LinkedIn
DevGrid on X
From the publisher's feed
Are you a tech leader, architect, or engineer navigating the intricacies of building within the enterprise? Tech Council delivers the strategies and insights you need to succeed. Hosted by Duncan…