Fowler, Beck Say AI Tools Require TDD Rigor as Micro-Craft Era Ends

Martin Fowler & Kent Beck: Frameworks for reinventing software, again and again — The Pragmatic Engineer

The Pragmatic Engineer

Automated test suites and modular architecture remain essential to verify unpredictable AI agents, but manual line-by-line code craft no longer provides engineering leverage.

AI-assisted summary of Martin Fowler & Kent Beck: Frameworks for reinventing software, again and again — original source. Check the original for full context.

Source published:

Key ideas

  • Twenty-five years after the Agile Manifesto, Martin Fowler and Kent Beck argue that artificial intelligence represents an inflection point far larger and faster than object-oriented programming, the internet, or Agile, requiring no persuasion to convince enterprises of its significance. (7:25)
  • Test-driven development and automated test suites have seen a renewed resurgence as the critical verification harness needed to keep unpredictable generative AI 'genies' aligned with human intent. (2:11)
  • The Venn diagram of developer experience (DX) and agent experience (AX) is effectively a circle: modularity, strict test harnesses, and precise domain modeling benefit both human engineers and autonomous LLM agents. (29:07)
  • Rather than downsizing software engineering groups into solo operations, Fowler and Beck predict two-pizza teams will persist with expanded leverage, warning against a dangerous managerial retreat into isolated, 're-soloed' programming. (25:10)

Detailed notes

## Background Published on YouTube by The Pragmatic Engineer on April 7, 2026, this session from The Pragmatic Summit features Martin Fowler and Kent Beck in conversation with host Gergely Orosz. The panel explores frameworks for reinventing software, drawing on twenty-five years of lessons since the Agile Manifesto to examine how past technology cycles inform the current generative AI shift.

## TL;DR Marking twenty-five years since drafting the Agile Manifesto, Martin Fowler and Kent Beck assess the unprecedented speed and scale of artificial intelligence across software engineering. They argue that while AI is often marketed as a way to eliminate programmers, foundational practices like Test-Driven Development, modular architectures, and domain modeling remain essential as verification harnesses for unpredictable autonomous agents. The pair caution against enterprise panic, security blind spots, and the antisocial 're-soloing' of development, advocating for resilient, collaborative two-pizza teams over isolated engineers juggling bots. Ultimately, while Beck candidly mourns the diminishing leverage of line-by-line code polishing, Fowler emphasizes that what benefits developer experience (DX) symmetrically benefits agent experience (AX).

## Atmosphere & style The session strikes a playful, collegial, and refreshingly unpretentious tone, driven by decades of rapport between Fowler and Beck as they trade dry self-deprecating quips about being the tech world's 'old furniture.' Rather than dispensing dogmatic advice from on high, both veterans speak with disarming vulnerability, openly sharing their initial frustrations with tools and admitting that no one currently holds definitive answers. The emotional arc transitions gracefully from sharp institutional critiques of corporate incentives and vendor snake oil to a poignant, bittersweet reflection on outgrowing the tactile craft of manual coding.

## Bulletin - [07:25](https://www.youtube.com/watch?v=CZs8J1ZD0CE&t=445s) Twenty-five years after the Agile Manifesto, Martin Fowler and Kent Beck argue that artificial intelligence represents an inflection point far larger and faster than object-oriented programming, the internet, or Agile, requiring no persuasion to convince enterprises of its significance. - [02:11](https://www.youtube.com/watch?v=CZs8J1ZD0CE&t=131s) Test-driven development and automated test suites have seen a renewed resurgence as the critical verification harness needed to keep unpredictable generative AI 'genies' aligned with human intent. - [29:07](https://www.youtube.com/watch?v=CZs8J1ZD0CE&t=1747s) The Venn diagram of developer experience (DX) and agent experience (AX) is effectively a circle: modularity, strict test harnesses, and precise domain modeling benefit both human engineers and autonomous LLM agents. - [25:10](https://www.youtube.com/watch?v=CZs8J1ZD0CE&t=1510s) Rather than downsizing software engineering groups into solo operations, Fowler and Beck predict two-pizza teams will persist with expanded leverage, warning against a dangerous managerial retreat into isolated, 're-soloed' programming.

## Key takeaways - [02:11](https://www.youtube.com/watch?v=CZs8J1ZD0CE&t=131s) The unpredictability of generative AI agents makes automated test suites and TDD principles more critical than ever to verify that candidate code matches developer intent. - [03:49](https://www.youtube.com/watch?v=CZs8J1ZD0CE&t=229s) Veteran engineering leaders no longer possess ready-made answers for software delivery, requiring senior practitioners to model rapid, low-cost experimentation rather than prescriptive authority. - [07:25](https://www.youtube.com/watch?v=CZs8J1ZD0CE&t=445s) The technological scale and adoption velocity of AI surpass earlier industry disruptions like object-oriented programming, the internet, or Agile. - [07:25](https://www.youtube.com/watch?v=CZs8J1ZD0CE&t=445s) Kent Beck compares the generative AI shift to the introduction of the Intel 4004 microprocessor, which shattered prevailing mental models of compute and vastly broadened developer imagination. - [10:56](https://www.youtube.com/watch?v=CZs8J1ZD0CE&t=656s) Navigating AI hype requires total skepticism paired with inward curiosity to design the smallest possible experiment that validates a tool's real substance. - [12:26](https://www.youtube.com/watch?v=CZs8J1ZD0CE&t=746s) Like early object-oriented programming and Agile, initial friction with AI often stems from improper tool usage rather than the underlying capability of the technology. - [15:41](https://www.youtube.com/watch?v=CZs8J1ZD0CE&t=941s) Corporate incentive structures and departmental politics routinely resist the 'faster, cheaper, better' efficiency promises of both Agile and AI. - [17:32](https://www.youtube.com/watch?v=CZs8J1ZD0CE&t=1052s) The rapid emergence of low-value consulting and marketing around AI mirrors the historic co-optation of Agile into the 'Agile industrial complex.' - [18:55](https://www.youtube.com/watch?v=CZs8J1ZD0CE&t=1135s) AI functions as a capability multiplier benefiting junior developers and high performers, but creates severe career vulnerability for the vast middle tier of vocational programmers. - [21:03](https://www.youtube.com/watch?v=CZs8J1ZD0CE&t=1263s) The recurring executive fantasy of eliminating programmers dates back to COBOL, yet writing prompts remains a formal specification of intent and code. - [22:41](https://www.youtube.com/watch?v=CZs8J1ZD0CE&t=1361s) Traditional enterprises face confusion, legacy scale hurdles, and severe security risks by granting autonomous agents unvetted access to corporate communications like email. - [25:10](https://www.youtube.com/watch?v=CZs8J1ZD0CE&t=1510s) Autonomous agents risk reviving the anti-social 're-soloing' of programming, undermining the collaborative dialogue that drove the success of Extreme Programming. - [27:03](https://www.youtube.com/watch?v=CZs8J1ZD0CE&t=1623s) Two-pizza teams augmented by AI are positioned to outperform solo-developer setups, with pair-programming sessions effectively guiding collections of autonomous tools. - [27:03](https://www.youtube.com/watch?v=CZs8J1ZD0CE&t=1623s) Longer model generation latencies offer a counterintuitive benefit by giving human pairs time to deliberate over design, architecture, and trade-offs. - [29:07](https://www.youtube.com/watch?v=CZs8J1ZD0CE&t=1747s) Engineering leverage is shifting away from micro-level code polishing and manual refactoring toward deep business domain comprehension and systemic architecture.

## Detailed walkthrough ### [00:05](https://www.youtube.com/watch?v=CZs8J1ZD0CE&t=5s) Old Furniture at an AI Gathering: 25 Years Since the Agile Manifesto

The session opens on an energetic and playful note as Gergely Orosz welcomes the audience to The Pragmatic Summit. Looking around at the crowd, Gergely admits he did not initially expect to see Martin Fowler and Kent Beck walking into a venue packed with the hottest modern artificial intelligence startups. Kent immediately feigns outrage, demanding, “What the hell is that supposed to mean?” Gergely confesses that he had already teased Kent earlier in the day by referring to him as "old furniture" and the elder statesman of the tech crowd. Kent dryly defends himself against the jab, pointing at Martin and retorting, “I'm at least a year younger than him.”

Transitioning into the substance of the talk, Gergely explains that just a week earlier, he, Martin, Kent, and several other prominent industry thinkers had gathered in Deer Valley, Utah, for the Future of Software Engineering conference, which Martin had organized. The gathering provided a timely moment of reflection: it has been twenty-five years since seventeen software practitioners met in Utah to draft the Agile Manifesto. As two of the original seventeen signatories, Martin and Kent have spent the ensuing quarter-century fundamentally shaping software engineering practices. Gergely asks them to reflect on the decades of feedback they have received from working engineers, probing which core ideas have truly stuck and what developers most frequently thank them for creating.

- Gergely Orosz, Martin Fowler, and Kent Beck had just convened at the Future of Software Engineering conference in Deer Valley, Utah, prior to the summit. - The Agile Manifesto was drafted twenty-five years ago by seventeen signatories, including both Martin Fowler and Kent Beck.

[02:11](https://www.youtube.com/watch?v=CZs8J1ZD0CE&t=131s) The Polarization of TDD and Verifying the AI "Genie"

Reflecting on Gergely's question, Martin notes that he has never systematically cataloged the feedback, though developers constantly bring up the broad philosophies of Agile as well as the specific disciplines laid out in his book *Refactoring*. Kent, however, points to an intensely bifurcated reaction to test-driven development. While many engineers express profound gratitude for TDD, others treat it like an apocalyptic curse. Kent humorously recites the complaints he receives: “I also get this test-driven development 'ruined my life. My dog left me. My house burned down and it's all your fault.'” Gergely agrees that TDD has always been inherently provocative, admitting that he himself was once a zealous convert before swinging toward frustration with the practice.

The conversation turns to modern relevance when Kent recounts a conversation from the previous day with an engineer pushing the cutting edge of AI development. The practitioner thanked Kent for championing TDD for over two decades, explaining that automated tests have suddenly become critical because software engineering now relies on autonomous AI agents. While Kent remains self-aware and cautious about confirmation bias—wondering if he is simply eager to hear praise that validates his life's work—he underscores that the core philosophy of TDD directly addresses the unpredictability of generative tools. When developers delegate work to an unpredictable assistant, having strict, programmatic verification is the only way to ensure the output matches human intent. As Kent Beck puts it: “It does make sense to me that, you know, when we've got a big powerful genie, you really have to learn how to verify that it's doing the right thing for you.” Martin adds that the industry has spent twenty-five years cultivating that exact verification reflex, to which Kent quips that although he is no genie himself, he has always relied on tests to keep his own code honest.

```mermaid flowchart LR accTitle: Verification loop for AI agents accDescr: Flowchart illustrating how human developer intent is turned into code by an AI agent and verified through automated test suites. subgraph Spec ["Specification"] A["Developer Intent & Prompts"] end subgraph Generation ["Autonomous Execution"] B["AI Agent ('The Genie')"] C["Candidate Code Output"] end subgraph Validation ["Safety & Verification Loop"] D["Automated Tests (TDD Harness)"] E["Verified Working Software"] end A --> B B --> C C --> D D -->|"Tests Pass"| E D -->|"Tests Fail / Regress"| B ```

[03:49](https://www.youtube.com/watch?v=CZs8J1ZD0CE&t=229s) Staying Grounded: Documenting Real Workflows and Helping Geeks Feel Safe

Addressing the audience's familiarity with their books and podcasts, Gergely brings up an abrasive LinkedIn comment he encountered before the summit. The commenter disparaged the conference lineup, complaining that the organizers had invited authors who were supposedly out of touch with real technology. Gergely brushes off the ignorance of the critique and asks Martin and Kent what their day-to-day work looks like now, and how they actively keep their fingers on the pulse of modern engineering. Martin explains that after publishing the second edition of *Refactoring* roughly five or six years ago, he deliberately chose not to write another book, despite having multiple half-finished manuscripts sitting on his desk. Instead, he decided to shift his full attention toward learning from practitioners in the field. Explaining his pivot, Martin Fowler states: “Instead, what I should do was work with people who are actually still doing real work on real projects, writing real code, as it were.”

Martin channels these insights directly into martinfowler.com, a platform he values because it remains entirely under his personal editorial control without corporate interference. In the era of AI, Martin is intensely focused on observing fine-grained developer workflows: how engineers converse with their AI assistants, what they look for during code reviews, and what critical decisions humans must still retain. Kent then articulates his overarching personal mission, stating plainly that his purpose in life is to help geeks feel safe in the world. Right now, he observes, technical workers feel profoundly unsafe due to industry upheaval. For twenty-five years, industry leaders had ready-made answers on tap—if a team suffered from bugs, coaches prescribed automated testing, and if code was untestable, they prescribed architectural refactoring. Kent observes that this era of reliable recipes has abruptly evaporated: “And the thing that's changed is at this moment nobody knows the answers to anything.”

Rather than offering obsolete prescriptions, Kent has retreated into "explore mode," tackling ambitious coding experiments to discover what works firsthand. He believes the duty of senior engineers is not to posture as authorities who have solved the AI transition, but to publicly model the experimentation required to navigate an unmapped technological landscape.

- Martin Fowler intentionally ceased writing standalone books after the second edition of *Refactoring* to focus on curating practitioner knowledge on martinfowler.com. - Martin’s primary research focus in AI centers on the exact mechanics of human-agent dialogue, review criteria, and how decision flows are shifting between humans and models. - Kent Beck argues that for twenty-five years experts could simply "press play on the recorder" to solve software problems, but that playbook has stopped functioning over the past year. - Kent views the role of veteran engineers as demonstrating how to discover new working methods rather than pretending to hold ready-made answers.

[07:25](https://www.youtube.com/watch?v=CZs8J1ZD0CE&t=445s) Historical Analogies: The Microprocessor, the Internet, and the Magnitude of AI

Gergely asks Martin and Kent to look back across their long careers and identify any prior technological inflection points that felt as daunting, unpredictable, and disorienting as artificial intelligence feels today. Martin immediately clarifies that nothing in their past matches the sheer scale of the current moment. While earlier waves triggered anxiety—the emergence of object-oriented programming scared many procedural programmers, the internet fundamentally transformed communication, and Agile met fierce institutional resistance—AI operates in an entirely different category of impact. During previous shifts, pioneers had to spend years evangelizing and persuading skeptical executives that these technologies mattered. In stark contrast, AI requires no persuasion; Martin Fowler notes: “People can't—I mean, you cannot put blinkers on to deny the importance of this thing.”

Kent offers another historical parallel from his childhood: the dawn of the microprocessor. Growing up in Silicon Valley with a programmer father, Kent remembers when computing power was confined to massive mainframe boxes that were so expensive an organization practically had to mortgage a building to acquire another one. When the Intel 4004 chip debuted, it shattered prevailing mental models of what a computer could be, instantly expanding the boundaries of human imagination. Kent sees that same imaginative explosion happening with AI today. In his own exploratory work, he has been using AI to pursue wildly ambitious projects that would previously have seemed impractical, such as building a persistent Smalltalk environment and writing library-quality Rust code. While many of these experiments fail, Kent emphasizes that failure is an intrinsic part of the process, reminding the audience that computing has faced moments before where sudden abundance unlocked unimaginable new horizons. As Kent Beck reflects on the creative surge: “And so, I think part of AI is this expansion of imagination.”

- Martin Fowler ranks previous disruptions—object-oriented programming, the internet, and Agile—as smaller in scale than AI, noting that pioneers previously had to fight just to convince people those technologies were important. - Kent Beck draws a direct comparison between generative AI and the release of the Intel 4004 microprocessor, which democratized compute away from room-sized mainframes. - To test the creative limits of AI, Kent is currently working on personal projects including a persistent Smalltalk system and production-grade Rust libraries.

[10:56](https://www.youtube.com/watch?v=CZs8J1ZD0CE&t=656s) Total Skepticism, Curiosity, and the Smallest Experiment

Navigating technological sea changes requires balancing raw curiosity with healthy doubt. Martin Fowler emphasizes that his own skepticism is hard-won, forged after decades of watching the tech industry peddle endless cycles of snake oil. While he was completely dismissive of earlier movements like blockchain, he stresses that true skepticism cannot be dogmatic—it must turn inward as well. As Martin Fowler explains: “My skepticism has to be absolute and total, which means I have to be skeptical about my skepticism.” That internal check forces an engineer to remain curious enough to look past their initial dismissals, continually probing emerging tools to detect whether genuine substance lies beneath the surface hype.

Kent Beck crystallizes this probing mindset down to an empirical, low-cost practice. The critical discipline in modern software engineering is determining how to run rapid micro-tests to see past vendor marketing without investing months of wasted effort. As Kent Beck puts it: “That's the skill that is suddenly in the last year become a thousand times more valuable is that skill of saying, 'What's the least I can do to validate for my to my own satisfaction whether this claim is true?'”

- The defining habit for navigating disruption is determining the smallest possible experiment to test whether a technology's claims are valid. - Skepticism must be paired with genuine curiosity so engineers do not discard breakthrough shifts prematurely out of sheer cynicism.

---

[12:26](https://www.youtube.com/watch?v=CZs8J1ZD0CE&t=746s) Early AI Impressions, Emacs, and Learning to Use the Tool

Early interactions with unpolished tools can easily send misleading signals. Martin recounts his own initial foray into AI copilots roughly a year to eighteen months earlier inside Emacs—jokingly acknowledged from the stage as "the one true editor." After configuring Emacs to prompt and auto-complete inline code, he found the experience deeply aggravating: while the model occasionally offered brilliant completions, it produced garbage so frequently that he spent half his time hitting `Ctrl-K` to kill lines of hallucinated text. Had he trusted that initial experience alone, he admits he would have flipped the "bozo switch" on AI just as he had done with blockchain.

Instead, Martin looked to practitioners who balanced grounded excitement with critical nuance. He credits Simon Willison's blog, alongside Thoughtworks colleagues Mike Mason and Birgitta Böckeler, with showing him that mastering AI requires learning how to wield it skillfully rather than blaming early friction on the concept itself. Martin draws a historical parallel to the early days of object-oriented programming, where developers claimed objects were ineffective while merely writing procedural code in C++ or Java without understanding true object design. Kent adds that the ground continues to shift underneath developers' feet weekly, noting how tools like Gemini or Claude Code will fail miserably one week and perform seamlessly the next on the exact same task. As Kent Beck reassures the audience with a grin: “So, you're just as smart as everybody else because you're just as ignorant as everybody else.”

```mermaid flowchart TD accTitle: Paths of Technological Adoption accDescr: Contrasting superficial trial and hype against empirical mastery and tool learning. subgraph Shift ["Technological Shift (OO / Agile / AI)"] Tech["New Paradigm or Tool"] end

subgraph Adoption ["Paths of Adoption"] Surface["Superficial Use & Hype<br/>(Early Copilot frustration, 'Agile Industrial Complex')"] Pragmatic["Disciplined Mastery<br/>(Simon Willison, small experiments, continuous probing)"] end

subgraph Outcomes ["Long-Term Reality"] Discard["Flipped 'Bozo Switch' / Snake Oil"] Amplified["Compounded Productivity & Amplification"] end

Tech --> Surface Tech --> Pragmatic Surface --> Discard Pragmatic --> Amplified ```

---

[15:41](https://www.youtube.com/watch?v=CZs8J1ZD0CE&t=941s) The Agile Illusion: Why Organizations Don't Want 'Faster, Cheaper, Better'

The conversation turns to the 25-year milestone of the Agile Manifesto, published in 2001. When asked why his name appeared at the very top of the original seventeen authors on the website, Kent dryly notes that the order was "strictly alphabetical," before admitting, "it is a source of unending joy." The moderator highlights how Agile entered the industry with four simple core values that promised to deliver better software faster and cheaper—the exact same value proposition executives now anticipate from generative AI.

Kent completely punctures this assumption, arguing that engineers routinely misunderstand corporate dynamics. While technical workers assume management shares the goal of hyper-efficiency, corporate political realities often reward friction, headcount, and predictability over radical efficiency. As Kent Beck observes: “Inside a company, the incentives are so misaligned with actually achieving that.” Engineers who arrive touting that a practice makes delivery 40% better, 12% cheaper, and "less fattening" are routinely punished because those metrics destabilize the internal incentives of other departments. Because the tech industry never solved that organizational dysfunction during the Agile era, Kent warns that AI adoption will run headfirst into the exact same political resistance.

- Kent Beck's name was placed first among the 17 Agile Manifesto signatories simply due to alphabetical ordering. - Corporate incentive structures routinely punish efficiency improvements that conflict with departmental budgets, staffing goals, or internal power structures.

---

[17:32](https://www.youtube.com/watch?v=CZs8J1ZD0CE&t=1052s) Speed, Snake Oil, and the Agile Industrial Complex

Comparing the two eras, Martin points out that while Agile took root across software engineering through a slow, decades-long burn, AI is slamming into the industry with unprecedented magnitude and velocity. Despite this difference in pace, the core human and institutional dynamics mirror each other closely. A stark divide will emerge between the minority of practitioners who invest the deep effort required to use the tools effectively and the majority who apply them carelessly.

Equally familiar is the immediate rise of grift and commodification. Just as the foundational ideas of Extreme Programming and Agile were engulfed by what Martin famously coined the "Agile industrial complex," AI is experiencing its own explosion of low-value consulting, tool peddling, and buzzword marketing. As Martin Fowler warns: “And that will happen. That is happening with AI right now, and it's often hard to see the difference between where is the snake oil and where is the real stuff.” Discerning between authentic productivity gains and predatory snake oil requires teams to remain vigilant and test tools empirically.

---

[18:55](https://www.youtube.com/watch?v=CZs8J1ZD0CE&t=1135s) Amplifiers, Junior Developers, and the Vulnerable Middle

Kent pushes back against the doom-and-gloom narrative surrounding software careers, arguing that AI functions primarily as a capability multiplier. For ambitious newcomers, he believes we have entered the "golden age of the junior programmer." He recounts speaking with anxious parents whose computer science students want to abandon programming for commercial alternatives like art history out of fear that AI will automate entry-level roles. Kent reframes the shift using a historical craft analogy:

> “And I'd say, well, this is like if you're a carpenter and they just introduced the circular saw and you think, oh well, carpentry is over. Anybody can build a house now. Well, no, you have more powerful tools. You have less time that you have to do, you know, kind of the crummy work.”

While top performers will become significantly more effective and hungry juniors will learn faster than ever, Kent expresses deep concern for "the middle"—the large cohort of developers who joined the industry purely as a reliable white-collar paycheck. During the dot-com crash 25 years ago, that group was flushed out and drifted into professions like real estate, but that middle cohort is vastly larger today. Martin adds that today's market dynamics are uniquely challenging compared to the late 1990s: the dot-com era was an unadulterated economic boom until its sudden pop, whereas the current AI revolution is colliding directly with brutal post-ZIRP (Zero Interest Rate Policy) tech retrenchments and corporate cost-cutting.

- High performers and juniors benefit most from AI because it acts as an amplifier, accelerating their learning and execution speed. - The vocational "middle" of software development faces acute disruption, with fewer obvious career escape hatches than existed after 2000. - Unlike the dot-com boom, the AI cycle is playing out against the backdrop of broad macroeconomic headwinds and tech sector layoffs.

---

[21:03](https://www.youtube.com/watch?v=CZs8J1ZD0CE&t=1263s) The Recurring Fantasy of Replacing Programmers

The discussion closes on the tech industry's cyclical obsession with engineering obsolescence. Kent reflects on the periodic corporate dream: "we get to get rid of all the programmers, woohoo." Martin interjects that this fantasy dates back at least to the creation of COBOL, which was pitched as a language so intuitive that non-technical business analysts could write all necessary instructions, eliminating the need for specialized programmers entirely.

While the Agile movement stood apart because it was created by programmers to empower programmers, modern AI rhetoric has reignited the executive dream of a developer-free enterprise. Kent cautions that rather than simply laughing off these recurring replacement narratives, engineers must confront why corporate leadership is so desperate to disintermediate them in the first place. As Kent Beck concludes: “Which it behooves us as programmers to think about why they keep wanting to get rid of us.”

[21:53](https://www.youtube.com/watch?v=CZs8J1ZD0CE&t=1313s) What Does "Getting Rid of Code" Really Mean?

Martin Fowler challenges the dramatic narrative currently circulating in industry panels and conference sessions that developers will completely stop writing code within six months. He points out that declaring code dead overlooks the reality of human-machine interaction: even when offloading work to an LLM, developers are still composing prompts and directing the system. That prompt interaction is itself a medium of formal intent, effectively functioning as an evolved form of programming.

While the nature, syntax, and abstraction level of code may change drastically, the fundamental requirement to articulate precise instructions and inspect the output remains intact. Fowler stresses that the underlying necessity to produce logic and maintain an interface with these automated "genies" will not simply vanish into thin air.

As Martin Fowler observes regarding the claim that nobody will write code in the near future: “What's that going to be if it's not some form of code in some way? I think the nature of what code is is going to be quite possibly for a very radically different. But I think there is still a need to produce it and be able to interact with it in some way.”

[22:41](https://www.youtube.com/watch?v=CZs8J1ZD0CE&t=1361s) Enterprise Confusion, Scale, and Security Blind Spots

When asked how traditional enterprises and skeptical clients are actually responding to generative AI on the ground—in contrast to the polished marketing narratives from leading research labs like OpenAI or tool vendors—Martin Fowler provides a blunt assessment of the landscape. Enterprise organizations operate under vastly different constraints than greenfield startups. Their systems are sprawling, fragile, and mission-critical; a codebase of one million lines of code is considered relatively small in enterprise environments, and risking downtime that could ground an airline for days is an unacceptable proposition.

Fowler expresses genuine alarm over reckless enterprise experiments that ignore fundamental security and access-control boundaries. He recounts discovering multiple groups, even within surprisingly large enterprises, proposing that LLMs be given complete, autonomous access to read and reply to employee email inboxes. Both speakers react with astonishment at the sheer operational and security risks involved in exposing private corporate communication channels to autonomous agents, warning of inevitable fallouts from the current blind rush to deploy flashy features.

As Martin Fowler characterizes the current state across enterprise engineering organizations: “Um at the moment large-scale confusion and panic is pretty much the order of the day right across the board.”

Highlighting the reckless rush toward adoption without adequate guardrails, Martin Fowler warns: “I am very much concerned we're going to have some really bad security incidents um over this year because people are just not paying attention.”

- Large enterprise systems face strict fault-tolerance limits where risking multi-day operational outages is out of the question. - Existing legacy systems view one million lines of code as an entry-level size, creating severe context-handling challenges for current tools. - Corporate initiatives to grant LLMs autonomous email reading and replying capabilities introduce critical security vulnerabilities.

[25:10](https://www.youtube.com/watch?v=CZs8J1ZD0CE&t=1510s) The "Re-Soloing" of Programming vs. Social Software Development

Kent Beck identifies what he sees as one of the most concerning behavioral regressions driven by the rise of AI tools: the "re-soloing" of software development. He reflects on how Extreme Programming (XP) was deliberately designed to construct a safe, highly collaborative social environment for engineers who might otherwise lean toward antisocial work habits. XP turned software creation into an intensely communicative human craft where teammates spent hours every day in continuous dialogue, testing assumptions against differing viewpoints and varying energy levels.

Today, however, Beck notices developers retreating into isolation while comforting themselves with the illusion that juggling automated tools makes them team leaders. Management, too, appears eager to revive the old Taylorist dream of isolated coders locked away in private offices where pizza was slid under the door. Many organizations view autonomous agents as a convenient excuse to replace vibrant, messy, high-performing human teams with isolated individuals managing silos of bots.

Kent Beck directly refutes the claim of individual engineers operating multiple bots: “No, you're not. You're using six tools at once, which is fine. But, it's that's very different than having a conversation with somebody who believes things that are a little different than what you believe.”

Recalling the uncomfortable managerial retreat away from human collaboration, Kent Beck observes: “And that was that was easy to manage and easy to control. And then along came this messy, social, complicated, chaotic process that just happened to produce really good results.”

[27:03](https://www.youtube.com/watch?v=CZs8J1ZD0CE&t=1623s) One-Pizza Teams, Effective Pairs, and the Joy of Slow Genies

The conversation turns to the future structure of engineering teams, specifically addressing the industry debate over whether classic "two-pizza teams" will shrink down to "one-pizza teams" simply because automated agents consume tokens rather than food. Fowler firmly places his bet on two-pizza teams remaining the gold standard, arguing that human teams augmented by agents will drastically expand their capabilities rather than simply shrinking headcount. Furthermore, pairing dynamics may evolve beyond one human using tools into pairs of humans driving agents together, or even mob programming sessions orchestrating collections of genies to maintain critical oversight.

Beck adds an unexpected, counterintuitive observation about working in a human-pair-plus-genie setup: he actually prefers models when they are slightly slower. When an agent takes several minutes to process a complex prompt, it creates natural breathing room for the two human engineers to discuss naming philosophies, architectural trade-offs, and conditional logic. Hyper-fast responses, while impressive benchmarks on paper, disrupt that reflective collaborative cadence by demanding immediate, relentless code review.

Stating his conviction on team sizing, Martin Fowler declares: “My bet is on the more effective two pizza teams.”

Reflecting on the loss of thinking time as model latency shrinks, Kent Beck notes: “And if it pops back in 15 seconds, you don't have time to have that conversation.”

- Two-pizza teams are likely to become significantly more capable rather than being downsized into solo operations. - Pair programming is evolving into two human engineers collaboratively supervising and steering AI agents. - Longer model generation latencies (e.g., three minutes) provide essential cognitive breaks for human partners to debate architecture and design.

[29:07](https://www.youtube.com/watch?v=CZs8J1ZD0CE&t=1747s) Developer Experience vs. Agent Experience, and Mourning the Craft

In the closing segment, the discussion turns to guidance for craft-focused software engineers and leaders wondering how to thrive amidst shifting abstraction layers. Fowler introduces an idea he heard that resonates deeply: the Venn diagram of developer experience (DX) and agent experience (AX) is essentially a circle. The exact same disciplines that make a codebase readable and maintainable for human developers—modular architecture, comprehensive and reliable automated test suites, and clear domain modeling—are precisely the structural affordances that allow LLM agents to operate effectively without hallucinating or breaking systems. Fowler cites his ThoughtWorks colleague Animesh Joshi, who discovered that building a precise, shared domain language to talk to agents is essentially Domain-Driven Design (DDD) repurposed for prompt-level precision.

```mermaid flowchart TD accTitle: Overlap of Developer and Agent Experience accDescr: Flowchart illustrating how foundational software craft practices equally benefit human developer experience and AI agent experience. subgraph Core["Foundational Engineering Craft"] M["Modular Codebases"] T["Rigorous Automated Tests"] L["Precise Domain Language (DDD)"] end subgraph Outcomes["Symmetrical Benefits"] DX["Developer Experience (DX)<br/>Clarity, maintainability, fast feedback"] AX["Agent Experience (AX)<br/>Bounded context, test verification, reduced hallucinations"] end M --> DX M --> AX T --> DX T --> AX L --> DX L --> AX ```

Kent Beck closes on a raw, vulnerable note of mourning for the micro-level craft of programming. He admits to taking an obsessive, therapeutic satisfaction in opening a messy file, taking tiny and disciplined refactoring steps, and watching the code snap into elegant focus. However, he acknowledges that spending hours perfecting individual functions no longer offers meaningful leverage. To stay relevant and effective, engineers must redirect their passion away from line-by-line code aesthetics and toward mastering the broader business domain and its structural connection to software systems.

Highlighting the deep alignment between traditional craft and AI tooling, Martin Fowler remarks: “The point here is that, you know, what we do that that's good for the agents is good for the humans and vice versa.”

Bidding farewell to the microscopic joys of manual refactoring, Kent Beck reflects with palpable grief: “Because that that satisfaction of getting this one function just right just doesn't make a difference anymore.”

- High modularity and decoupling make codebases substantially easier for both human teammates and autonomous agents to parse. - Test-Driven Development and solid automated test suites provide critical verification boundaries for agent-generated code. - ThoughtWorks consultant Animesh Joshi emphasizes establishing precise domain modeling vocabularies when prompting agents to maximize accuracy. - Engineering leverage has definitively migrated from micro-level code polishing to deep systemic domain comprehension.

## Notable quotes > [10:56](https://www.youtube.com/watch?v=CZs8J1ZD0CE&t=656s) My skepticism has to be absolute and total, which means I have to be skeptical about my skepticism. — Martin Fowler

> [02:11](https://www.youtube.com/watch?v=CZs8J1ZD0CE&t=131s) It does make sense to me that, you know, when we've got a big powerful genie, you really have to learn how to verify that it's doing the right thing for you. — Kent Beck

## Mentioned Martin Fowler, Kent Beck, Gergely Orosz, The Pragmatic Engineer, The Pragmatic Summit, Agile Manifesto, Refactoring, martinfowler.com, Simon Willison, Mike Mason, Birgitta Böckeler, Animesh Joshi, Thoughtworks, Intel 4004, Smalltalk, Rust, Emacs, Claude Code, Gemini, COBOL

## Video description With Martin Fowler and Kent Beck. At The Pragmatic Summit: www.pragmaticsummit.com. See a writeup of the talk: https://newsletter.pragmaticengineer.com/p/cycles-of-disruption-in-the-tech

Watch the session with Q&A also included: https://newsletter.pragmaticengineer.com/p/the-pragmatic-summit-recordings

0:00 Intro 2:11 Ideas from Agile/TDD/refactoring that stuck 9:04 Historical analogies: microprocessor, internet, OO, Agile 16:44 Why good practices still fail 21:21 How the AI shift is different 25:50 Engineers as managers of multiple agents 27:11 One-pizza vs two-pizza teams 29:07 Developer experience and agent experience

[Source](https://www.youtube.com/watch?v=CZs8J1ZD0CE)

Reading summary

Twenty-five years after co-authoring the Agile Manifesto, Martin Fowler and Kent Beck argue that generative artificial intelligence does not eliminate software engineering, but intensifies the need for foundational disciplines like automated verification, modular design, and social collaboration. While AI acts as a powerful capability amplifier, its integration is complicated by institutional friction, security vulnerabilities, and shifting professional boundaries. Verification and the Alignment of Human and Agent Experience (2:11) Beck and Fowler observe that automated testing has gained renewed urgency because autonomous AI agents act as unpredictable generators requiring strict programmatic boundaries. Rather than rendering test-driven development obsolete, working with non-deterministic tools makes rigorous automated suites the primary mechanism to verify that candidate code matches developer intent. Fowler notes that the software industry spent a quarter-century cultivating this verification habit, which now serves as a safety harness for autonomous agents. Furthermore, Fowler highlights that the requirements for developer experience (DX) and agent experience (AX) largely overlap. Foundational engineering disciplines—modular codebases, loose coupling, comprehensive test suites, and precise domain vocabularies drawn from Domain-Driven Design—are identical to the structural affordances that prevent large language models from hallucinating or breaking production systems. Clean interfaces and clear domain boundaries benefit automated tooling just as much as human maintainers. Organizational Resistance and the Recurring Replacement Fantasy (15:41) Addressing executive expectations that AI will make delivery radically faster and cheaper, Beck warns that corporate incentives rarely reward raw efficiency. Just as the Agile movement met bureaucratic resistance because dramatic productivity gains destabilized departmental staffing goals and budgeting metrics, AI adoption faces identical political friction. Both speakers caution that the tech industry is experiencing a surge of low-value consulting and marketing buzzwords akin to the commercialized "Agile industrial complex." At the same time, leadership's ambition to disintermediate developers is a cyclical phenomenon that Fowler traces back to the inception of COBOL, which was pitched as a plain-language tool that would eliminate specialized programmers. Fowler dismisses claims that engineers will stop writing code within months, explaining that prompt composition and instruction specification are themselves evolved forms of formal programming. In enterprise environments with codebases exceeding one million lines and strict fault-tolerance limits, Fowler reports widespread confusion, pointing specifically to reckless initiatives granting autonomous agents access to corporate email inboxes without adequate security boundaries. Countering the Re-Soloing of Software Development (25:10) Beck highlights a behavioral regression in modern engineering: the "re-soloing" of programming. While Extreme Programming intentionally structured software creation as a communicative, collaborative human process, modern tooling tempts developers to isolate themselves under the impression that managing multiple bots substitutes for human teamwork. Management similarly risks reviving Taylorist models of isolated workers to exert greater control over development. Fowler contends that augmented "two-pizza teams" will remain standard, predicting that collaborative groups driving AI models will outproduce isolated individuals. In pair-programming workflows where two engineers direct an agent, Beck notes a counterintuitive preference for slower model response times: when an agent takes a few minutes rather than seconds to execute a complex prompt, it introduces necessary cognitive breathing room for human collaborators to debate naming philosophies, architectural trade-offs, and underlying design constraints. Career Disruption and the Loss of Micro-Craft (18:55) Beck rejects the narrative that entry-level careers are disappearing, framing generative AI as a mechanical amplifier analogous to the circular saw in carpentry. High-performing engineers and hungry junior programmers stand to benefit most by accelerating their execution and learning loops. However, Beck and Fowler express deep concern for the vast "middle" cohort of developers who view programming merely as a white-collar paycheck, particularly as this disruption intersects with macroeconomic headwinds and post-ZIRP tech retrenchments. This structural shift also forces an emotional transition for seasoned practitioners. Beck acknowledges a genuine grief over losing the micro-level craft of programming, conceding that spending hours manually polishing and refactoring individual functions no longer provides competitive engineering leverage. To remain effective, developers must shift their focus away from line-by-line code aesthetics toward broad business domain mastery and systems architecture. Beck and Fowler conclude that navigating AI requires rigorous empirical testing through the smallest possible experiments rather than passive acceptance of vendor marketing. The central unresolved question is whether organizations can resist the temptation to isolate developers and bypass security controls, using AI instead to enhance collaborative human teams that remain accountable for software correctness.

Source quotes

[10:56] Martin Fowler: My skepticism has to be absolute and total, which means I have to be skeptical about my skepticism. [2:11] Kent Beck: It does make sense to me that, you know, when we've got a big powerful genie, you really have to learn how to verify that it's doing the right thing for you.

Original transcript

[0:05] Welcome everyone. It's It's It's so nice [0:07] to see all of you. It's so nice to see [0:10] a lot a lot of friendly faces. A lot a [0:11] lot of you said hi. And also just really [0:13] good to to meet Martin and Ken. And I [0:16] was joking a little bit beforehand that [0:19] I did not expect Martin Fowler and Kent [0:22] Beck to walk into a place where it's all [0:24] the kind of the hottest AI startups and [0:27] all of them. But here we are and we're [0:28] here for a very very good reason. [0:30] What? [0:32] >> What What the hell is that supposed to [0:34] mean? [0:37] >> Oh Oh gosh, here we go. I [0:40] So [0:41] Ken Ken is going to hate me for this cuz [0:42] today I already called him old furniture [0:45] once. [0:46] >> I don't think that's fair. [0:48] Old furniture. Yeah, you're the old guy [0:51] in the crowd. [0:54] I'm at least a year younger than him. [0:57] >> Uh [0:58] but we're I I I'm psyched that both of [1:01] you are are here. And a week ago, me, [1:04] Martin, Kent, and a bunch of other [1:06] people were in Deer Valley, Utah [1:09] in the Future of Software Engineering [1:11] conference that Martin pulled together [1:13] some some very interesting thinkers. And [1:15] we were talking about like [1:17] it was a nice to reflect that 25 years [1:19] ago the Agile Manifesto was created. [1:28] There were 17 people and and two of you [1:31] and you were two of you you were there. [1:34] Since then, you've really helped shape [1:38] software engineering as you've helped [1:41] influence and and you've had major [1:42] contributions. [1:43] Could I ask both of you to like recap [1:45] what [1:46] the feedback you've gotten over over [1:48] these these years, these decades, what [1:50] ideas really stuck [1:53] with engineers? What What What What What [1:54] do you hear a lot they tell you like, [1:55] "Thank you for this. I'm using a lot of [1:57] this." [2:00] >> That's a really interesting question. I [2:02] haven't really reflected [2:04] on that. I mean, a lot of people talk [2:06] about things in general that we've [2:08] worked on. [2:09] Um whether it's Agile broadly or [2:12] refactoring particularly in my case [2:14] because that was a book I worked on. [2:16] Um but I don't know anything where any [2:19] of the pieces of that necessarily. [2:22] >> So, I get "Thank you so much for [2:25] test-driven development." I also get [2:28] this test-driven test-driven development [2:34] "ruined my life. [2:36] My dog left me. [2:39] My house burned down and it's all your [2:41] fault." So, I don't know. Does that [2:42] answer your question? [2:45] >> I I think TDD has has been very [2:47] divisive. I I've been a I've been a [2:50] convert at some point and then I I hated [2:52] but it's interesting cuz I feel a lot of [2:53] a lot of these these are a bit like [2:54] this, right? They're meant to be [2:55] provocative. They're meant to push you. [2:58] >> Yeah, I also got [3:00] I was actually chatting with somebody [3:02] yesterday who's really pushing the AI [3:04] envelope and his comment was, "Well, [3:06] thank goodness for all of your pushing [3:08] of TDD for the last 20 years because [3:11] it's really important that we've got AI [3:13] agents." [3:14] And uh [3:16] it it's interesting to hear that [3:17] feedback because um I'm always [3:20] suspicious of it cuz I want it to be [3:22] true. You know, I'm the kind of guy who [3:24] when when I hear something I like, I'm [3:26] kind of thinking, "Am I just making this [3:27] up?" But uh it does make sense to me [3:31] that, you know, when we've got a big [3:32] powerful genie, you really have to learn [3:34] how to verify that it's doing the right [3:36] thing for you. [3:37] >> Which we've been practicing for 25 [3:40] years. [3:40] >> Yeah. Well, I mean, I'm not a big [3:42] powerful genie myself but I still needed [3:44] the tests to make sure I was doing the [3:46] right thing. [3:49] >> So, a a lot a lot of folks here, they [3:51] will know you from the podcast that we [3:52] did together. They might have they [3:54] probably read some of your books. [3:55] Barton, you're really prolific writer, [3:57] but can you tell us what are you up to [4:00] these days? What is your day-to-day look [4:02] like? How do you stay in touch with [4:03] technology? I got a really rude comment [4:05] that I'm still I got to fight into [4:07] someone on LinkedIn about this. [4:09] They said like, "Oh, your your [4:10] conference like you're having authors [4:11] here who are like out of touch with [4:13] technology." And I'm like, "Do you even [4:15] know who [4:16] Martin Fowler and Kent Beck is?" But I [4:18] just want wanted to wanted to uh ask [4:20] like these days how What are What are [4:22] you up to? Seriously. [4:23] >> Well, my I when I finished the second [4:26] edition of Refactoring book, which was, [4:28] you know, five or six years ago, I toyed [4:31] with the idea of writing another book. [4:32] I've got several half-written books out [4:35] there to work on. And I decided I should [4:37] not do that. [4:38] Instead, what I should do was work with [4:41] people who are actually still doing real [4:44] work on real projects, writing real [4:46] code, as it were. [4:47] Um and get them to get their ideas out [4:50] and what they learn out. So, that's been [4:54] my main project ever since, primarily [4:56] focused on the martinfowler.com website, [4:58] because [5:00] hey, I control that. There's no big [5:01] corporation that's going to sweep in and [5:03] and clubber it with at least not without [5:05] my [5:06] um me selling out and getting lots of [5:07] money out of it. [5:08] Um [5:10] and um [5:12] as the AI thing has come, I've been very [5:14] keen to capture that. And what my big [5:17] focus is on is trying to [5:19] understand details of people's workflow [5:22] and what exactly they are doing. What [5:24] are the kind of conversations they're [5:25] having with the genies, as Kent um calls [5:28] it. And you know, what if you're [5:31] reviewing things, what are you looking [5:32] for? If And what in particularly what [5:35] decisions are you uh we the humans still [5:38] making? And how is that decision flow [5:40] changing? [5:42] Um so, that's my interest is it's not [5:44] what I'm doing, it's what my colleagues [5:46] are doing and trying to spread that [5:48] around, and that's that's my focus. [5:51] >> Yeah, so I've been [5:53] uh my personal mission in life is to [5:57] help geeks feel safe in the world. [6:00] And uh our people do not feel safe right [6:03] now. [6:04] For some good reasons and some not good [6:06] reasons. And [6:09] one of the things I noticed is for 25 [6:11] years we've kind of had the answers. [6:13] Somebody comes to us and says we have [6:15] too many bugs or like, all right, well, [6:17] here's how you write tests. Oh, I can't [6:19] write tests. Well, here's how you design [6:20] so you can write tests. It's [6:22] just kind of press play [6:24] uh on the recorder. And the thing that's [6:27] changed is at this moment nobody knows [6:31] the answers to anything. [6:34] And so what I've been trying to do is [6:37] both for my own geeky curiosity [6:40] satisfaction, [6:41] let me go back into explore mode and [6:44] find out as well as I can [6:48] uh [6:49] what you can do to be effective with [6:51] these new tools, [6:52] and then demonstrate that to the next [6:56] generation of people who've been used to [6:58] getting answers. Oh, I'm having some [7:00] trouble. Let me look up in the book what [7:03] the solution is. That that worked for [7:05] the last 20 years, and it doesn't work [7:08] for the last year, and won't work for [7:11] the an extended period. So, [7:13] as seniors, I figure it behooves us to [7:16] demonstrate not just how to use these [7:18] tools effectively, but how to figure out [7:20] how to use these tools effectively, cuz [7:22] that's a whole different set of skills. [7:25] >> And [7:26] you say, all right, we don't know [7:28] what what will come out. No one has it [7:29] figured out. I want to take you back [7:32] into your professional journey. One [7:34] thing that you share here, you have seen [7:36] a lot more than a lot of us, myself [7:37] included, a lot of people in in the room [7:39] as well. [7:41] Do you remember a time where there was a [7:43] technology change which looked similarly [7:45] kind of unpredictable or scary like AI [7:48] does right now? [7:49] What was the thing that comes the [7:51] closest [7:52] in your career? [7:54] >> Well, nothing has hit with the magnitude [7:57] of AI. That's I mean, this is a a whole [8:01] size difference from anything that we've [8:03] faced before. [8:04] Um on a smaller scale, [8:07] um I would say and we were very much [8:11] involved in the the growth of [8:12] object-oriented languages. I mean, and [8:14] that scared a lot of people. It didn't [8:15] scare us so much cuz we were part of it. [8:18] Um [8:19] I would say that the impact of the [8:21] internet [8:22] um had a huge impact upon us all. Um [8:27] And of course, obviously, we were [8:29] spreading the the the challenge of Agile [8:31] software development, and that had a [8:32] very big impact on a lot of [8:35] organizations because you could tell by [8:36] how hard they resisted it. [8:38] Um but the thing about AI is that, you [8:41] know, [8:42] all of many of these things we were [8:44] talking about how important they were [8:45] and how valuable were and trying to [8:46] persuade people of the importance of [8:48] them. Yes, even the internet. That may [8:50] sound surprising, but there were people [8:52] who would weren't thinking that was [8:53] important. [8:54] Um but AI, there's kind of no argument [8:56] about how important it is. People can't [8:59] can I mean, you cannot put blinkers on [9:02] to deny the importance of this thing. [9:04] >> So, the the other analogy that I have is [9:07] to the introduction of the [9:08] microprocessor. [9:10] Um before that, computers were a big [9:12] box. You couldn't move them around. If [9:14] you wanted another one, you'd mortgage [9:17] your house again. [9:18] It was a It was a big It was a big deal, [9:21] and [9:22] I was a kid in Silicon Valley with my [9:24] dad as a programmer when [9:27] the Intel 4004 hit, and we went, "Wait a [9:31] minute. That's a computer? [9:33] Oh my goodness. The the possibilities [9:38] suddenly expanded. [9:40] If you can figure out how to write [9:42] software, if you can figure out how to [9:43] design hardware around this thing, you [9:46] can suddenly do things we can't even [9:48] imagine. And so, [9:51] uh I think part of AI is this expansion [9:55] expansion of imagination. So, I'm [9:58] writing projects that are ridiculously [10:00] ambitious. I'm working on a persistent [10:04] smalltalk. I I'm writing library quality [10:08] code for Rust. I'm just, you know, [10:12] anything I can imagine that I'm trying [10:14] to do, I'm going to try and do it and [10:16] see. Now, a a bunch of those fail and [10:19] that's fine. That's part of this [10:20] process, but um [10:23] it it's not like this is the first time [10:25] the heavens have opened and and we've [10:28] been brought tons of new opportunities. [10:32] >> Um back either with with object-oriented [10:35] spreading or with microprocessors, do [10:38] you remember what the the feeling was in [10:40] the industry and what was the difference [10:42] between experienced professionals who, [10:44] you know, just got [10:46] thrived in this new world and ones who [10:48] were just, honestly, left behind? [10:53] Yeah, [10:54] with all of those, there was that sense [10:56] of the mix between the the the people [10:59] chasing the hype and the the people who [11:01] were saying, "No, this is nothing [11:02] special." Um I think it you've always [11:05] got to have that balance of skepticism [11:09] and curiosity. [11:11] Um in order to be able to do that. And [11:13] you are selective about it. I mean, I [11:14] have been completely skeptical about [11:16] some big um changes. I mean, um [11:19] blockchain, for instance. I was [11:20] extremely skeptical about that. [11:23] Um and but [11:25] as I like to say, you know, about about [11:28] my skepticism about technologies, which [11:30] is well rooted cuz I've seen so much [11:32] snake oil projected out by the industry [11:35] over the years. My skepticism has to be [11:38] absolute and total, which means I have [11:41] to be skeptical about my skepticism. [11:43] And that requires that curiosity. And I [11:46] think that's where the thing is. You've [11:48] got to be curious enough to say, "May [11:50] This looks like but maybe it isn't. How [11:53] do I probe in order to detect that the [11:56] signs of of something coming out there?" [11:58] >> Yeah, what what's the smallest [11:59] experiment I can run to verify to my own [12:03] satisfaction [12:04] and everybody's level of satisfaction is [12:06] going to be different [12:08] whether or not this claim is true. [12:11] That's That's the skill that is suddenly [12:14] in the last year [12:16] become a thousand times more valuable is [12:19] that skill of saying, "What's the least [12:21] I can do [12:22] to validate for my to my own [12:24] satisfaction whether this claim is [12:26] true?" [12:26] >> But there's also another step in there [12:28] that you also got to be aware that your [12:31] early interactions may not actually be a [12:34] a true signal. I mean when I started [12:37] playing around with AI [12:40] I guess it was the co-pilot-y like stuff [12:42] about a year year and a half ago [12:45] I was pretty unimpressed, right? I mean [12:47] I I I set up I'm an Emacs guy. I set up [12:51] Emacs. [12:52] Yeah, the one true editor. [12:54] Um [12:56] I set it I set up Emacs so that I could [12:58] just have it prompt and complete [13:00] automatically, cuz you know, Emacs is [13:02] capable of doing that. And I used it for [13:05] maybe three or four days before I just [13:07] got Cuz sometimes it would give you [13:09] something wonderful, but most of the [13:10] time it gave you such garbage that you [13:12] would just control K right away. [13:14] And if that had been my impression of AI [13:17] and I had have said, "That's what I I [13:19] think of AI." I would have just [13:21] immediately flipped the bozo switch on [13:23] it just like I did with blockchain. [13:26] But on the other hand, I'm also probing [13:28] out there. So, my my [13:31] most valuable discovery in all of this [13:34] is in the room next door, Simon [13:36] Willison's blog, which I read, and one [13:39] of the things that I took from that was [13:41] to use this tool well, you have to learn [13:43] how to use it well, which was also [13:46] something very true of object [13:47] orientation. People would say, "Oh, [13:48] objects We're doing And I would you'd [13:50] look at what they were doing, you're not [13:51] using objects very well." [13:54] That we kind of This Kent as I were kind [13:56] of at Yeah, they were using C++ and [13:58] Java. They didn't actually do the real [13:59] stuff. [14:00] Um but the the point was you have to be [14:04] also listening to the folks out there [14:06] and being able to read with a critical [14:08] eye and getting a sense of okay, if you [14:12] do run across a Simon Willison, [14:14] is he hyping everything wonderful or [14:17] does he seem to be [14:19] recognizing real problems at the same [14:21] time and giving me straight stuff? [14:23] And that I found was a really I mean [14:25] when people [14:27] give you that balance of good and bad [14:29] and also most importantly are prepared [14:31] to say I don't know, [14:33] then that that involves something to [14:35] listen to. So, him and also some of my [14:37] colleagues in Fort Worth, like Mike [14:39] Mason and Biggy to Burkler, they really [14:41] kind of showed me that oh, I shouldn't [14:43] be relying too much on my initial [14:45] reactions. [14:47] >> Yeah, and it can change week to week. I [14:49] I'll I'll I'll I'll try something with [14:52] Gemini one week, [14:54] fails miserably. [14:57] This Gemini thing [14:58] cloud code uh [15:00] then that works pretty well, then it's [15:02] doesn't work well, and then I tried [15:03] Gemini for the same thing, [15:05] and it works this week, and it didn't [15:07] work last week. [15:09] That's a You know, people want the [15:11] answer, and the answer is changing. So, [15:13] you can't possibly in this environment [15:17] have the answer. [15:18] Now, that's the bad news. The good news [15:20] is nobody else has the answer either. [15:23] So, you're just as smart as everybody [15:26] else because you're just as ignorant as [15:28] everybody else. [15:30] >> Is that reassuring? [15:32] >> Is that reassuring? By show of hands. [15:41] >> One thing that struck me as like a bit [15:45] of a similarity is back in 2001 when the [15:48] almost exactly 25 years ago when the [15:50] Agile Manifesto came out with that [15:52] website with all the 17 names listed and [15:54] Kent Beck being the first one. Why were [15:56] you the first one? [15:57] >> Alphabetical. [15:58] Strictly alphabetical. [16:00] But, it is a source of unending joy. [16:05] >> You can very much like it that. [16:10] That that that kicked off some really [16:12] interesting thing in the industry [16:14] because what what my interpretation was [16:17] like, well, use this Agile, here's these [16:19] four pretty simple, easy to understand, [16:21] and easy to identify with things to [16:23] build better software, faster, cheaper, [16:26] higher quality, you name it. Now, when I [16:28] think of why so many companies are [16:30] adopting AI, they're kind of expecting [16:32] the same thing, better, faster, cheaper, [16:34] and so on. And so, I wanted to Can you [16:36] reflect on [16:38] how Agile actually went, speaking of [16:40] snake oil? [16:41] >> Well, it turns out that people don't [16:43] want faster, cheaper, better. [16:46] >> Tell me more. [16:47] >> Inside a company, the incentives are so [16:49] misaligned with actually achieving that. [16:54] And [16:55] so as as geeks trying to achieve that [16:58] and say, well, it's 40% better and it's [17:01] 12% cheaper and it's less fattening. [17:05] Uh [17:06] people will punish you for that if that [17:08] doesn't align with their incentives [17:10] inside of organizations. [17:13] Yeah, in the ideal organization, [17:15] everybody would care about the same [17:16] things and that's just not the way it [17:19] works. [17:22] >> But I [17:23] >> So, and and we haven't touched that [17:25] problem. So, if AI is coming along to [17:27] promise the same things, we're going to [17:29] see exactly the same reaction. [17:32] >> And and this is what I I wanted to ask, [17:33] like looking back from what you've seen [17:34] for Agile now 25 years and it played out [17:36] at a lost lost slower slower slower [17:39] pace, what similarities do you see right [17:42] now with AI? How do you think the curve [17:44] could fit? And also, what is very [17:46] different about that Agile movement and [17:49] and that took the industry by like a [17:50] very slow storm, and now with AI? [17:54] >> Well, what's obviously very different is [17:55] the sheer magnitude and speed that's [17:58] that is hitting with AI. So, that is [18:00] definitely different. I suspect one [18:03] thing with I think there will still be [18:04] some similarities. Um one of them I [18:08] think is there will be a big difference [18:09] between people who use it well and [18:12] people who use it badly. [18:14] And the trick is figuring out how to use [18:17] it well and putting the effort in to [18:19] learn to use it well. [18:20] Um I think there will be a big [18:22] distinction between those two groups. [18:25] Um I think another similarity is I mean, [18:28] the core notions uh behind Agile and [18:31] extreme programming are solid and good, [18:33] but a huge snake oil industry appeared [18:36] around it, the Agile industrial complex [18:38] as I like to refer to it. Um and that [18:41] will happen. That is happening with AI [18:43] right now, and it's often hard to see [18:45] the difference between where is the [18:46] snake oil and where is the real stuff. [18:48] And so, that's another thing that you've [18:50] got to be constantly probing and be [18:52] aware of and be wary of as as you're [18:54] looking at it. [18:55] >> Yeah, AI is an amplifier. [18:58] And if uh [19:00] if you're young and learning quickly, AI [19:03] is going to amplify that or can amplify [19:06] that. So, I I personally think this is [19:08] this is the golden age of the junior [19:10] programmer. I get people coming to me [19:12] all the time. Oh, my son had started his [19:15] second year in CS and he wants to go [19:17] into something more commercial like art [19:19] history. [19:22] And I I'd say well, this is like if [19:24] you're a carpenter [19:26] and they just introduced the the [19:30] circular saw and you think, oh well, [19:32] carpentry is over. [19:34] Anybody can build a house now. [19:38] Well, no, you have more powerful tools. [19:40] You [19:41] you have less time that you have to do [19:44] you know, kind of the crummy work. [19:47] So, I think that that's a [19:49] the the young people who are learning [19:50] faster going to learn faster. [19:52] The experienced people who are working [19:55] effectively are going to work more [19:57] quickly and more effectively. [19:59] And my concern, and this is something I [20:01] learned [20:03] last week, that middle [20:05] if we look back at the dot-com crash, [20:08] there was a there was a um a middle of [20:11] people who'd gotten into programming [20:13] because it was a way to make money [20:16] and those people went into real estate [20:18] more or less. [20:20] And I don't know where the middle's [20:23] going to go now cuz that middle is much [20:25] bigger now than it was 25 years ago. [20:28] >> But that middle has also been flushed [20:30] out to some degree by the retrenchments [20:32] in the software industry at the end of [20:34] the zero interest rate period. Um so, [20:37] that's an interesting difference because [20:39] we've had these two things occurring at [20:40] once, the AI boom and the economic [20:44] headwinds that we've had in the last two [20:46] or three years. [20:47] Um so, which is an interesting kind of [20:49] mix of things that wasn't the case back [20:51] in the '90s with the dot-com boom cuz [20:54] that was pretty much all solid boom. [20:56] >> Yeah. [20:57] So, [20:58] another [20:59] interesting uh confluence of factors is [21:03] we have these periodic we get to get rid [21:06] of all the programmers, woohoo. [21:09] >> Cobol, the end of programming. [21:11] >> Starting with Cobol, right? When the [21:13] business analysts were going to be able [21:14] to write the programs and we didn't have [21:16] to have programmers anymore. [21:18] And so that comes back repeatedly. Agile [21:23] was definitely not that. We wanted [21:25] programmers to be more effective in [21:28] their jobs. And since we started it and [21:31] we're programmers, we were able to [21:33] push that agenda pretty effectively. [21:36] But now now we have this repeating [21:39] this repeating, "Hey, we get to get rid [21:41] of all the programmers." Which it [21:42] behooves us as programmers to think [21:44] about why they keep wanting to get rid [21:46] of us. [21:48] Some of that's about us and some of it's [21:51] not, but some of it is. So we should [21:53] think about that. But also that ants [21:56] amps up the fear factor that everybody [21:59] is experiencing. [22:01] >> And also one of the interesting things [22:02] is when people will say, "Oh, we're [22:03] getting rid of code." I mean, and the uh [22:06] you hear people saying sessions, "Oh, no [22:08] one's going to write code in 6 months' [22:09] time." [22:10] I go to myself, "Well, yeah, but what do [22:13] you mean by code?" [22:15] Because that kind of implies nobody's [22:17] writing anything. Well, we're at least [22:19] doing some prompting. We're having some [22:21] interaction with the genie. [22:23] What's that going to be if it's not some [22:25] form of code in some way? I think the [22:28] nature of what code is is going to be [22:31] quite possibly for a very radically [22:33] different. But I think there is still a [22:35] need to produce it and be able to [22:38] interact with it in some way. [22:41] >> What one thing I really like and respect [22:43] about both of you is you are two feet on [22:45] on the ground. We've heard from OpenAI, [22:47] who are leading lab, and of course [22:48] they're building amazing technology, but [22:50] they also have to talk their book. We've [22:52] heard about Laura, who talks with so [22:54] many people and so has so many good [22:56] insights. [22:57] In the end, you know, she will have a [22:59] small bias to to help sell some of the [23:01] tools that that help do this. Martin, [23:04] you're talking with so many companies, [23:06] especially like large skeptical [23:07] companies as well as well as startups as [23:10] to ThoughtWorks consulting advising and [23:12] so do you can. What do you see on the [23:14] ground? What is interesting and what is [23:16] surprising you about how these smaller [23:18] and larger companies often the the more [23:21] enterprise ones, the more traditional [23:22] ones, what are they doing with the [23:24] technology and how are they thinking [23:25] about it? [23:27] >> Um at the moment large-scale confusion [23:29] and panic is pretty much the order of [23:32] the day right across the board. [23:33] >> So so if that is your strategy, you're [23:36] right in the middle. [23:39] >> I mean enterprise I mean large [23:41] enterprises have this thing where they [23:42] just have enormous amounts of code and [23:45] complex systems that fit together in [23:47] difficult to get over ways. [23:49] Um where someone says, you know, can can [23:52] these tools handle a million lines of [23:54] code because that that's a smaller code [23:56] base as far as many of these systems are [23:58] concerned. And it's a very different [24:00] picture to the startup world because no, [24:03] you do not want to take a risk that's [24:05] caused going to cause your airline to go [24:07] offline for a day or two. That's not an [24:10] acceptable um thing to consider. [24:12] Um and also um there are other risks [24:15] involved. I mean I I've now run into [24:18] several different groups including some [24:20] at surprisingly large companies that are [24:22] talking about let's have the LLM have [24:25] complete control over my email. It can [24:27] read all my emails and it can reply to [24:30] most of the emails. [24:31] AND I'M GOING [24:33] >> NO. [24:33] >> WHAT? [24:35] >> NO. [24:36] >> I MEAN THE SECURITY RISK OF that is, you [24:39] know, mind-boggling. Um but, you know, [24:42] it's a very it's I [24:43] I am very much concerned we're going to [24:45] have some really bad security incidents [24:48] um over this year because people are [24:50] just not paying attention. [24:52] And um [24:54] those are the kinds of things that are [24:55] out there as well. So, there's a kind of [24:57] blind rush to [25:01] uh say, "Let's Let's Let's grab these [25:03] nice looking things at the same time as [25:05] some real concerns that are coming [25:07] across it as well." [25:09] >> So, [25:10] I see a a big trend is the re-soloing of [25:15] programming. [25:16] Where [25:18] a big part of extreme programming is [25:20] creating a safe social environment for [25:24] basically antisocial people. [25:28] Not just asocial, antisocial. [25:33] And the when I think about the degree of [25:36] interaction on an XP team, [25:39] people aren't [25:40] talking to each other hours a day and [25:42] happy to be doing so because it's set up [25:45] for that to be a positive experience. [25:48] What I see now is, well, [25:50] "I'm a a programmer and I've got six [25:52] agents. So, really I'm managing a team." [25:56] No, you're not. [25:58] You're using six tools at once, which is [26:00] fine. [26:01] But, it's that's very different than [26:03] having a conversation with somebody who [26:06] believes things that are a little [26:07] different than what you believe. Or [26:10] somebody who's got a different energy [26:12] level today than you have. And but I I [26:16] see the the the trend is, "Oh, good. [26:20] We used to have programmers, you [26:22] remember individual offices? We We had [26:26] offices and doors and you shut the door [26:28] and you slide the pizza under." [26:30] >> It was a thing. [26:31] >> And And that was That was easy to manage [26:34] and easy to control. And then along came [26:37] this messy, social, complicated, chaotic [26:40] process that just happened to produce [26:43] really good results. [26:45] And uh that was uncomfortable. "Oh, [26:47] good. [26:49] I can You know, instead of having 50 [26:51] people on my team, I have five people on [26:53] my team. They don't have to talk to each [26:55] other. [26:56] And they can each have 10 agents and [26:57] that's the same. It's not the same. [27:02] >> Yeah, that's the uh [27:04] I mean, it's part of the question that [27:05] that [27:06] uh and again, it's something that was [27:08] discussed last week, you know, are we [27:09] seeing that, you know, two pizza teams [27:12] are going to become one pizza teams [27:13] because agents don't eat pizza? [27:16] Or do we see two pizza teams re- [27:19] staying, but just being able to much be [27:22] much more effective and capable? My my [27:26] >> Or Or do you create a genie that can eat [27:29] pizza? That's the one that [27:33] >> My bet is on the more effective two [27:35] pizza teams. [27:37] Um and it it's also some interesting, [27:39] you know, feedback we're beginning to [27:40] get in terms of pair programming. I [27:41] mean, with pair programming, do you say [27:42] pair programming is the human and the [27:45] genie? [27:46] Or is it two humans and and genies? [27:49] Because if it's two of us, we can [27:51] control the genies perhaps a little bit [27:53] better. And we also have that same [27:56] interaction. And I I'm going to find it [28:00] very interesting to hear reports of [28:01] people trying that kind of route where [28:03] they're saying, "Yes, we have those [28:05] pairs controlling genies." Um and [28:08] possibly beyond pairs. I mean, we we [28:10] There's also the whole mob programming [28:11] thing and [28:13] whether that will go a route with that [28:15] combined with the genies that [28:17] combination. I But I don't necessarily [28:19] think one person, many genies is [28:22] necessarily the right answer. [28:23] >> It's the simplest thing to to [28:26] understand. It's the simplest framing. [28:28] But my my experience pairing with a [28:32] two humans and a genie or multiple [28:34] genies has been very positive. And the [28:36] fact that they're kind of slow [28:38] is really nice. So, every time the [28:40] models come out and they're faster, I'm [28:42] like, "Oh, there's less time to talk." [28:45] You give a prompt and it's like, "Oh, [28:47] well, blah blah blah and then it's gone [28:49] for 3 minutes and we can talk about our [28:51] philosophy of naming or, you know, how [28:53] do we express conditionals or what other [28:57] you know, what should we be doing next? [28:59] And if it pops back in 15 seconds, you [29:01] don't have time to have that [29:02] conversation. [29:05] >> So, a lot of things are are changing. As [29:08] as a closing question before we we head [29:10] over to a Q&A, [29:12] for software engineers who really care [29:14] about the craft and engineering leaders [29:15] who care about the craft and you know, [29:16] they they've learned to love this [29:17] industry, they're seeing a lot of things [29:19] are shifting. For example, you're not [29:20] writing the code, you're losing a lot of [29:21] control. [29:22] What advice would you give to them to, [29:24] you know, stay stay afloat and and [29:26] hopefully come out thriving from this [29:28] this change in abstraction, basically? [29:31] >> I I like to think of a comment, again, [29:33] that came up last week and I can't [29:34] remember who to who I shouldn't [29:36] attribute it to, [29:38] um [29:39] which is that the the Venn diagram of [29:41] developer experience and agent [29:43] experience is a circle. [29:47] And the point here is that, you know, [29:49] what we do that that's good for the [29:51] agents is good for the humans and vice [29:52] versa. I'm hearing a lot of feedback [29:54] saying, "Yeah, actually, if you have [29:56] well-modularized code, that actually [29:58] makes it easy for the agents to work [29:59] with." And we've we're already getting, [30:02] you know, lots of reinforcement saying, [30:03] "Actually, focusing on tests, good [30:06] tests, helps the agents as well as helps [30:09] us." So, I think there's there's a good [30:11] bit of potential overlap here. And [30:13] again, this could be me again, just [30:15] wishful thinking cuz I want it to be [30:16] true, [30:17] um but uh I'm going to run with it for a [30:19] bit, at least. And I think So, focus on [30:21] those craft things. And focus on [30:25] um [30:26] using that and teaching the agent, as it [30:29] were, and working with the agent to find [30:31] and find out how best to express that. [30:33] Uh one of the things that uh I found [30:35] really fascinating was talking with [30:37] another colleague of mine, Animesh [30:38] Joshi, about how he was working in [30:41] domains and he says [30:42] the way he finds working often with an [30:44] agent is to try and develop a language a [30:47] precise language to communicate about [30:49] the domain with the agent which is [30:51] basically the kind of model building [30:53] language building domain driven design [30:55] stuff that we're used to doing but it [30:57] makes him more efficient to talk to the [30:59] agent. So those kinds of things give me [31:01] a sense of this this definitely a huge [31:03] overlap between what is good about our [31:05] practices and what will be good [31:08] continuing to drive with AI. [31:11] >> So I think for me I take a kind of uh [31:15] OCD enjoyment in the in the craft. [31:20] And I need to let go of that. [31:23] Because that that satisfaction of [31:25] getting [31:26] this one function just right [31:30] just doesn't make a difference anymore. [31:34] Uh [31:36] getting an overall understanding of [31:38] what's going on and and I say this with [31:40] sadness. [31:42] Because I really enjoyed getting in the [31:44] zone and you got some file and it's a [31:46] big mess and you make tiny little safe [31:49] steps and you don't know quite where [31:51] it's going and then you start to get a [31:53] glimmering and then it's there and then [31:55] oh pop it just pops into focus and it oh [31:58] that feels so good and I can't do that [32:01] anymore. [32:03] But I can still develop an overall [32:06] understanding of what I'm doing. [32:08] And I need to shift my focus to enjoying [32:12] understanding the domain [32:15] and its connection to my program in a [32:18] way that I used to be focused on the [32:21] program as the domain and I could make [32:24] that better and better [32:26] just doesn't have leverage anymore.