Podcast Summary: How AI will change software engineering – with Martin Fowler

The Pragmatic Engineer, Host: Gergely Orosz

Guest: Martin Fowler (Chief Scientist, ThoughtWorks, co-author of the Agile Manifesto)
Date: November 19, 2025

Episode Overview

This in-depth episode explores the seismic impact of AI—especially large language models (LLMs)—on software engineering. Host Gergely Orosz sits down with Martin Fowler, a renowned author and influential figure in the field, to discuss how AI is reshaping workflows, tools, mindsets, and team dynamics, as well as the enduring importance of core engineering skills like refactoring. The conversation also reflects on historical changes in the industry, the origin of influential concepts like Agile, and offers candid advice for the next generation of engineers.

Key Discussion Points & Insights

1. Historical Context: Comparing AI’s Shift (00:00–17:50, 16:53–24:56)

• AI as the Most Disruptive Change Since High-Level Languages:
  • Martin Fowler sees the current AI revolution as even more significant than prior shifts like object-orientation or Agile.
  • Comparable only to the transition from assembly to high-level languages.

    “The comparable thing would be the shift from assembly language to the very first high level languages... The biggest part is the shift from determinism to non-determinism.” (Martin, 00:06 & 16:53)

• From Determinism to Non-Determinism:
  • Traditional software was predictable: given input X, output Y.
  • AI injects non-determinism; the same input can yield different, less predictable results.

    “We’re working with an environment that’s non-deterministic, which completely changes software development.” (Martin, 00:17)

2. AI Workflows & Engineering Practices (26:24–38:33, 46:02)

• Rapid Prototyping & Vibe Coding:
  • LLMs excel at enabling fast, throwaway prototypes for experimentation or “vibe coding.”
  • Valuable for explorations, not for production quality, long-term software.

    “It’s good for explorations, it’s good for throwaways, but you don’t want it for anything with long-term capability.” (Martin, 00:28 & 33:42)

• Understanding Legacy Systems:
  • AI can analyze and query complex legacy codebases, rapidly surfacing flow of data across large systems.

    “If you’re doing any work with legacy systems, you should be using LLMs in some way to help you understand.” (Martin, 28:33)

• Learning & The Engineer’s Learning Loop:
  • Danger: over-reliance on LLMs or mindless use (“vibe coding”) breaks the crucial feedback loop where developers learn from the code they write.
  • Output from LLMs can be correct but incomprehensible, making maintenance difficult.

    “If you’re not looking at the output, you’re not learning...all you can do is nuke it from orbit and start again.” (Martin, 35:34)

3. Challenges with AI Integration (31:03–38:33, 43:23–45:36)

• Code Quality & Testing:
  • AI-generated code must be treated as code from an overly productive but unreliable collaborator—thorough review and testing are essential.

    “Treat every slice [of work] as a PR from a rather dodgy collaborator…You can’t trust the thing that they're doing.” (Martin, 30:35)

• Testing Remains Critical:
  • LLMs often “hallucinate” test results or fabricate explanations.

    “When the LLM tells me, ‘I ran all the tests, everything’s fine’, you got five failures.” (Martin, 44:05)

  • Professionals must always verify, never trust by default.

    “Don’t trust, but do verify.” (Martin, 45:30)

• Team Dynamics Unclear:
  • Most LLM engineering experiments are currently greenfield and solo—how to safely leverage LLMs in legacy code, team settings, or regulated industries is still an open question.

    “Most software has been built by teams and will continue to be built with teams… how do we best operate with AI in a team environment?” (Martin, 32:36)

4. Building & Communicating Abstractions (21:43–24:56, 37:36)

• Constructing Domain Languages:
  • LLMs may facilitate easier creation of custom DSLs or internal abstractions, but establishing precise and rigorous communication remains essential.

    “An old Lisp adage: create your own language…and then solve your problem…That leads to flexible code.” (Martin, 22:33)

• Spec-Driven Development:
  • Experimentation with having LLMs work off finely written specs, akin to “waterfall,” but Martin cautions against excessive up-front design.
  • Emphasizes tight feedback loops and thin vertical slices.

    “Do the smallest amount of spec…get it tested, get it in production, and then cycle…That’s key.” (Martin, 46:58)

5. The Enduring Value of Refactoring (56:34–65:59)

• Refactoring’s Lasting Role:
  • As code volume increases with AI tools, ongoing small, disciplined refactoring is even more important to maintain understandability and manageability.

    “If you’re going to produce a lot of code of questionable quality…but it works, then refactoring is a way to get it into a better state.” (Martin, 64:11)

  • LLMs struggle with large-scale, safe refactoring; human judgment remains critical.
    • “At the moment, [LLMs] can’t definitely refactor on their own… combining tools may help.” (Martin, 64:11)
• Code Review and Code Quality:
  • Increase in volume of AI-generated code puts pressure on code review processes; maintaining rigor is vital.

6. Design Patterns & Software Architecture (67:31–74:53)

• Patterns as Communication:
  • Patterns’ main value is in vocabulary for design discussions, not in cramming as many as possible into a codebase.

    “Patterns are only useful in certain contexts. What we're trying to do is to evolve that same kind of language [as the medical field]” (Martin, 69:02)

  • Patterns have faded from the limelight, perhaps due to overuse, generational change, and the rise of ready-made cloud building blocks.

    “Maybe patterns will become more fashionable again. I’m always looking for ways to spread knowledge around.” (Martin, 70:44)

7. Agile’s Journey and its Relevance in the AI Era (78:16–87:02)

• Agile Manifesto Origins:
  • Written as an attempt to legitimize incremental, test-driven, collaborative development over waterfall, which was then industry dogma.

    “We are uncovering—a continuous process—and the manifesto is a snapshot in time.” (Martin, 81:54)

• Adoption & Misinterpretation:
  • Agile enabled engineers to work more effectively, but often misapplied or reduced to buzzwords.

    “There’s a lovely quote: your brilliant idea will either be ignored or misinterpreted, and you don’t get to choose which.” (Martin, 81:44)

• Applying Agile with AI:
  • Core principle remains rapid, incremental delivery with tight feedback loops.
  • AI may further speed up prototyping and iterations, but frequent human review and focus on learning cycles remain vital.

    “I’d rather get smaller, more frequent slices than more stuff in each slice…Improving cycle time is our best leverage.” (Martin, 85:33)

8. Advice for Junior Engineers & Staying Current (94:53–97:37; 88:44)

• Mentorship is Key:
  • Juniors should seek senior engineers for guidance in learning, code quality, and source criticism.

    “A good, experienced mentor is worth their weight in gold…Seek out somebody like that who can be your mentor.” (Martin, 95:35)

• On Using AI Tools:
  • Use LLMs as an aid, but probe for reasoning, context, and never accept outputs blindly.

    “The AI can be handy, but always remember it’s gullible and likely to lie to you. Be probing: why are you giving me this advice?” (Martin, 95:35)

• Staying Up-to-Date:
  • Martin emphasizes learning from people actively experimenting (“I work with people writing articles...my primary form of learning”), trusted sources like Birgitta Böckeler and Simon Willison, and always looking for sources that discuss trade-offs and context rather than giving black-and-white answers. (Martin, 88:44)

9. The State of the Industry & Outlook (97:44–101:53)

• Massive Demand but Macroeconomic Turbulence:
  • Despite AI hype, overall tech is experiencing a depression due to macroeconomic factors (end of zero-interest rates) with substantial layoffs—though AI may be an exception.

    “What’s most important is not AI, it’s the end of zero interest rates…Weird mix of depression in software with an AI bubble.” (Martin, 97:44)

• AI Will Change, but Not Replace, Engineering:
  • The core of good software engineering remains: understanding what to build and communicating with stakeholders.

    “AI won’t wipe out software development…it’ll change it in a manifest way, like the change from assembly to high-level languages did, but the core skills are still there.” (Martin, 100:32)

Notable Quotes & Moments

• On non-determinism (00:17, 16:53):
  “The biggest part of it is the shift from determinism to non determinism. Suddenly you're working in an environment that's non deterministic which completely changes software development.”
• On vibe coding (00:28, 33:42):
  “It's good for explorations… but you don't want to use it for anything that's going to have any long-term capability… When you're using vibe coding, you're removing a very important part of something—which is the learning loop.”
• On advice for juniors (95:35):
  “The hard part, if you're more junior, is you don't have this sense of to what extent is the output good…Find some good senior engineers who will mentor you…The AI can be handy, but always remember it's gullible and likely to lie to you.”
• On the importance of refactoring (64:11):
  “If you’re going to produce a lot of code of questionable quality…but it works, then refactoring is a way to get it into a better state while keeping it working. These tools at the moment can't definitely refactor on their own...”
• On learning and humility (91:10):
  "What I'm always looking for is a lack of certainty... When people tell me, 'I know the answer,' I'm usually a bit more suspicious... It's trade-offs, nuances. That increases my confidence."

Important Timestamps

| Segment | Topic Details | |-------------------------------------------|---------------------------------------------------------------------------------------------| | 00:00–00:17 | Martin compares AI revolution to high-level languages, stresses determinism-to-non-determinism shift | | 26:44–28:33 | AI use in rapid prototyping and understanding legacy systems | | 31:03–32:36 | Using LLMs as a “dodgy” collaborator, code review, greenfield vs. legacy, team dynamics | | 33:42–36:38 | Risks of “vibe coding,” losing the learning loop | | 43:23–45:30 | The criticality of human-led review and verification | | 56:34–65:59 | Lifelong role of refactoring in the AI era, challenges with automated refactoring | | 67:31–74:53 | Decline of design patterns, the evolution of architecture language | | 78:16–85:33, 87:02–88:12 | Agile’s ongoing relevance, importance of rapid iterations and feedback loops | | 94:53–97:37 | Martin’s advice for juniors, mentorship, skepticism towards AI output | | 97:44–101:53 | Macro trends in the industry, resiliency in engineering, AI as a tool not a replacement |

Rapid-Fire Q&A & Recommendations (102:49–107:47)

• Favorite languages:
  Ruby (for familiarity); Smalltalk (for joy and expressiveness).
• Books:
  • Thinking, Fast and Slow by Daniel Kahneman (“great for developing intuition about probabilities/statistics”).
  • The Power Broker by Robert Caro (“brilliantly written, powerful on understanding real-world power”).
• Board game:
  Concordia (“easy to get into, rich in decision-making”).

Conclusion & Takeaways

• AI and LLMs are a step change—they make rapid exploration and access to “disposable” code easier than ever, but also threaten core learning processes if used carelessly.
• Fundamentals—testing, refactoring, communication, and incremental delivery—are more critical than ever in an age of AI-generated code.
• Always verify, never trust LLMs blindly; mentorship and critical thinking are essential for learning and growth.
• History shows that even “solved” problems (refactoring, architecture, patterns) resurface with each new technological wave—and adapting these practices thoughtfully is key to thriving in the AI era.

For further reading:
See the Pragmatic Engineer blog for deep dives, and Martin Fowler’s site (martinfowler.com) for curated articles from experienced practitioners.

Summary compiled in the thoughtful, conversational spirit of the original discussion, highlighting major themes and actionable insights for engineers and leaders alike.