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:

• AI is changing the economics of software delivery
• Transformation starts above the engineering team
• Coding is no longer the bottleneck
• Agile was really about decision-making and flow
• AI is pushing software teams toward ‘AI-left’ workflows
• Code review and validation are becoming harder
• The future team is smaller but more specialized
• Judgment matters more than syntax
• Build vs. buy is becoming more strategic
• The future belongs to adaptable learners

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

Jason Ehmke

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:

• Garry Tan's public statements about his coding activity and the backlash he received for the perceived quality of his code
• Relevance of lines of code as a metric for productivity, especially in the context of AI and automation
• Shifting focus from code quantity to business outcomes and customer acquisition 
• How coding practices have evolved with more capable browsers and computers, reducing the need for extreme optimization
• Importance of aligning engineering efforts with business goals and outcomes
• Trend towards open-source models and the challenges of maintaining proprietary advantages
• Cost of AI models and the economic implications of using different models
• Strategies for managing technical debt through automation and the balance between shipping quickly and maintaining quality

Connect with us:

Duncan Mapes

Jason Ehmke

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:

• Top-down automation is less about what you can do and more about what you should prevent.
• Organizations that automate vulnerability patching or compliance checks without addressing foundational process flaws see only short-term gains; systems designed to prevent these issues inherently scale better.
• The power of hints and context over APIs transforms complex data into actionable intelligence.
• Embedding guidance about data connections in MCP definitions enables agents to generate comprehensive security posture reports in minutes, instead of months of integration work.
• Frontloading data integrity and organizational knowledge shortcuts future complexity.
• Most organizations balk at cleaning or standardizing data upfront, but doing so creates a resilient backbone for automation.
• The future of enterprise AI relies on self-sufficient, organizationally aware agents.
• Systems that can autonomously build, navigate, and connect their own data pipelines will unlock scalable intelligence that adapts as organizations evolve.
• Simplifying complexity by integrating seamlessly and reducing friction transforms organizational agility.
• Reducing informational friction accelerates decision cycles and shifts human focus toward higher-value creative and strategic work.
• Privacy and security guardrails are essential to enable AI while safeguarding sensitive data.
• Without organizational constraints, AI adoption risks undermining security and eroding customer trust, nullifying productivity gains.
• Inclusivity in tooling is a strategic differentiator.
• Offering multiple modalities—CLI, MCP, APIs—ensures diverse user personas and workflows are supported, increasing overall adoption and impact.

Connect with us:

Duncan Mapes

Jason Ehmke

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:

• As AI automates routine and technical work, professional value shifts from task mastery to abstract problem framing and oversight skills.
• Organizations that recognize this shift will prioritize adaptable thinkers over task specialists, fundamentally redefining expertise and hiring criteria.
• A senior developer no longer needs deep low-level system knowledge; instead, success depends on defining success criteria and guiding AI outputs effectively.
• Trust in leadership and systems isn't presumed; it is actively built by designing organizational processes that empower autonomy and reduce unnecessary oversight.
• High-trust organizations accelerate innovation and agency, whereas distrust breeds resistance and stifles utilization of powerful tools like AI.
• The rapid acceleration of technological change, driven by AI and digital tools, demands a mental shift from managing change chronologically to embracing continuous, adaptive learning.
• If leaders and teams cling to outdated mental models, they risk obsolescence; adaptability becomes the new competence.
• Organizations should treat upskilling as a renewal of mindset, not just skill acquisition, embedding flexibility into learning pathways and decision-making.
• Fear of AI stems from its non-deterministic nature and unpredictability, challenging traditional notions of control and certainty in processes.
• Organizations that understand this can develop better guardrails and guard their confidence, turning fear into structured experimentation rather than paralysis.
• Setting explicit context, guardrails, and understanding input-output variability allows organizations to embrace AI’s complexity rather than fear it.
• Distributing AI champions within teams, rather than centralizing control, creates a resilient ecosystem where skilled individuals drive innovation without bureaucratic bottlenecks.
• AI’s capacity to handle specific tasks shifts organizational focus toward creating and shipping value, rendering traditional task management increasingly obsolete.
• Given the unprecedented and fast-evolving AI landscape, organizations must adopt a mindset of ongoing experimentation rather than static, rigid strategies.

Connect with us:

Duncan Mapes

Jason Ehmke

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:

• Automation can lead to faster outputs but may compromise craftsmanship.
• The value of a product is determined by the clarity of its inputs.
• Fast execution does not guarantee a quality product.
• Quality assurance is crucial in maintaining customer trust.
• Rapid development can lead to overlooking critical details.
• The evolution of tools requires a shift in planning and execution strategies.
• Production data is inherently messy and complex.
• Feature flags are essential for testing in production environments.
• Dockerization enhances the performance of AI agents.
• The context in which AI operates is crucial for its effectiveness.
• Software development resembles the process of writing a novel.
• Acceptance criteria are vital for defining project completion.
• Best practices in enterprise software development are critical.
• The future of software development is uncertain and requires adaptability.
• Continuous shipping and iteration are key to success.

Connect with us:

Duncan Mapes

Jason Ehmke

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:

• Carving out time for tech debt is crucial.
• Stop the bleeding by confronting existing issues.
• Defining 'good' is essential for team alignment.
• Visibility in metrics helps prioritize efforts.
• Gamification can engage developers in improving metrics.
• Compliance has significant economic implications.
• Vulnerabilities often represent theoretical risks.
• Creating a culture of measurement drives improvement.
• Transparency in leadership fosters accountability.
• Lean into measurement to influence positive change.

Connect with us:

Duncan Mapes

Jason Ehmke

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:

• AI tools are changing the software development landscape.
• Speed of development can lead to overlooked edge cases.
• Feature flags can help manage production risks.
• Agile methodologies have evolved from waterfall approaches.
• Automated testing is crucial for maintaining quality.
• Understanding customer needs is essential for product success.
• Iterative development allows for faster feedback loops.
• Cultural factors influence product development processes.
• Differentiation in products is key to standing out in the market.
• The role of engineers is shifting towards management and oversight.

Connect with us:

Duncan Mapes

Jason Ehmke

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:

• Understanding the current capabilities is crucial for transformation.
• Building relationships is key to gaining buy-in from stakeholders.
• Empathy plays a significant role in technology management.
• Transforming team roles requires a shift in mindset.
• Cost management should focus on value rather than just savings.
• Education and support empower teams to be self-sufficient.
• Being present during incidents provides valuable insights.
• User experiences can reveal underlying issues with technology.
• Leadership is essential in driving organizational change.
• Modeling best practices can inspire others to follow suit.

Connect with us:

Duncan Mapes

Jason Ehmke

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:

• AI tools are revolutionizing coding workflows, allowing for rapid prototyping and iteration.
• The CLI tools like Claude and Codex are becoming essential for developers.
• The last 10% of a project is often the hardest, but AI can help streamline this process.
• Design and usability remain critical, even as coding becomes more automated.
• The economics of development are shifting as AI reduces the time and cost of building software.
• Open-source models are gaining traction, but proprietary models still dominate the market.
• AI is not just a replacement for developers but a tool for enhancing their capabilities.
• The future of mobile development may see a resurgence of native apps due to AI tools.
• Companies need to adapt their workflows to integrate AI effectively.
• The competition between AI models is intensifying, with new players entering the market.

Connect with us:

Duncan Mapes

Jason Ehmke

DevGrid.io

DevGrid on LinkedIn

DevGrid on X

Tech debt exists at the intersection of engineering, business incentives, and system architecture. In complex organizations, it becomes a multidimensional problem involving operational risk, system reliability, long-term scalability, and developer productivity. 

In this analytically grounded episode, Duncan and Jason dissect tech debt through the lens of system thinking.

They introduce a working model for categorizing tech debt into functional, structural, and data-related risk, explaining how each impacts throughput, incident frequency, and time-to-recovery. They also examine how vulnerabilities and poor data contracts masquerade as “bugs” but are often symptoms of deeper architectural debt. 

The conversation presents a practical playbook for leaders: how to assess tech debt, measure its economic impact, define acceptable thresholds, and integrate it into strategic planning.

Top Takeaways:

• Tech debt can be defined in various ways depending on context.
• Shortcuts taken to meet business needs contribute to tech debt.
• Tech debt is not just about code quality but also about business outcomes.
• Standards change over time, leading to new tech debt.
• Quantifying tech debt is essential for effective management.
• Managing tech debt requires strategic planning and documentation.
• Business leaders need to understand the implications of tech debt.
• Justifying tech debt investments is a common challenge.
• Effective communication with business partners is crucial for tech debt management.
• A structured approach to documenting tech debt can aid in prioritization.

Connect with us:

Duncan Mapes

Jason Ehmke

DevGrid.io

DevGrid on LinkedIn

DevGrid on X