More The Pragmatic Engineer episodes

Stop being skeptical about AI for development with Charity Majors thumbnail

Stop being skeptical about AI for development with Charity Majors

Published 12 Aug 2026

Duration: 01:25:32

"AI's impact on software engineering is reshaping code review, reliability, and career paths, demanding new verification methods, ethical accountability, and adaptability in a rapidly evolving field."

Episode Description

Brought to You By:* Antithesis - verify your system's correctness without human review or traditional integration tests - and avoid bugs or outages.*...

Overview

The podcast discusses the growing divide in software engineering over the adoption of AI, highlighting two distinct perspectives: those who embrace it as essential for staying competitive and those who are skeptical due to observed reliability issues and degraded system stability. Central to the discussion is the evolving role of code review, with the argument that engineers will inevitably ship AI-generated code they haven't read - mirroring existing practices in operations and QA, where engineers routinely deploy code they didn't write. The conversation emphasizes that as AI increases code output, the bottleneck shifts from writing to validating code, necessitating stronger testing, observability, and engineering discipline.

The discussion expands to broader implications of AI in software development, including the need for robust verification mechanisms, especially given AI's non-deterministic nature. It underscores that AI demands more - not less - engineering rigor, with a focus on structured telemetry, auto-instrumentation, and proactive observability to manage complexity. The podcast also explores organizational shifts, such as the declining role of middle management and the rising value of individual contributors with AI skills, while advocating for ethical, human-led technological adoption. Themes of trust, accountability, and the importance of maintaining human judgment in AI-augmented workflows are consistently emphasized.

What If

  • What if you shipped AI-generated code without reading it, but with full test coverage and observability?

    • Move: Set up a prototype service where AI generates a complete feature (e.g., user onboarding API), you write integration and contract tests first, then deploy the AI-generated implementation directly to staging with full telemetry.
    • Why Now?: AI code generation is advancing faster than review capacity; teams are already hitting bottlenecks in manual validation - now is the time to shift from "reading code" to "validating behavior."
    • Expected Upside: 3 - 5x faster feature delivery on low-risk services while maintaining reliability through automated verification, freeing you to focus on system design and edge cases.
  • What if you replaced your legacy code module entirely with AI-generated code instead of patching it?

    • Move: Pick a small, painful, legacy component (e.g., a reporting script), use AI to generate a clean rewrite with equivalent inputs/outputs, validate via automated diff testing, and deploy behind a feature flag.
    • Why Now?: AI lowers the cost of rewrites dramatically - what used to take weeks can now be done in hours, and the industry is moving from "edit in place" to "generate and replace" as the default.
    • Expected Upside: Eliminate technical debt faster, improve maintainability, and establish a repeatable pattern for future rewrites - turning refactoring from a chore into a routine operation.
  • What if you treated your AI agent as an untrusted junior developer and applied Ops-style validation to every commit?

    • Move: Build a CI pipeline that runs AI-generated code through automated conformance tests, schema validation, security scans, and performance baselines - only promoting changes that pass, without human review.
    • Why Now?: AI is producing orders of magnitude more code, overwhelming traditional review processes; Ops has decades of experience managing untrusted changes in production.
    • Expected Upside: Maintain or improve code quality while scaling output, reduce review fatigue, and create a sustainable, auditable workflow for AI-assisted development as a solo operator.

Takeaway

  • Adopt AI-generated code cautiously by implementing robust testing and validation workflows, treating AI like any "unreliable agent" whose output must be verified before deployment.
  • Shift focus from manual code reviews to automated verification and early architectural alignment, reserving human review for high-impact design and product decisions.
  • Invest in observability early by using auto-instrumentation (e.g., OpenTelemetry) to capture rich, structured telemetry that reveals relationships between system events.
  • Rebuild trust in AI outputs through strict guardrails, deterministic testing, and production-like validation - especially for non-deterministic AI behaviors.
  • Upskill immediately in AI tooling as a solo developer; treat AI proficiency as a career necessity to remain competitive and avoid obsolescence in hiring pipelines.

Recent Episodes of The Pragmatic Engineer

29 Oct 2026 Software engineering at Google & CS education with Titus Winters

"Critiques CS education, advocating for AI-informed, practical curricula focused on problem-solving, teamwork, and real-world development, while examining Google's engineering practices, productivity challenges, and the need for deterministic tools in AI-driven software engineering."

21 Oct 2026 The revised rules of engineering management with Will Larson

"Engineering management is evolving, with outdated 2010s practices giving way to business-focused problem-solving, AI-driven role shifts, and adaptable leadership that prioritizes high-ownership teams and reskilling for long-term success."

7 Oct 2026 Building resilient systems with Sam Newman

Recommended: Good Engineering Decisions

"Microservices are a last-resort architecture requiring careful state management, while resilient systems depend on robustness, rebound, extensibility, and adaptability, with AI augmenting but not replacing human oversight in development."

30 Sept 2026 Distributed databases with Peter Mattis

"Software engineer and Cockroach Labs co-founder Peter Mattis discussed his career in database design, distributed systems, AI's impact on development, and the evolution of his leadership role, stressing rigorous testing, security, and the transformative potential of AI in coding."

23 Sept 2026 Design Engineering with Maggie Appleton

"Explores the evolving role of design engineers, blending engineering and design principles, analog tools, AI, and interdisciplinary collaboration to shape intuitive, culturally aware digital experiences."

More The Pragmatic Engineer episodes