Google Warns AI Code Surges Risk Breaking Developer Infrastructure

Software engineering at the tipping point — Google for Developers

Google for Developers

Accelerated AI code generation multiplies maintenance liabilities rather than true engineering velocity, threatening to paralyze compilation, review, and test pipelines unless organizations overhaul their underlying socio-technical ecosystems.

AI-assisted summary of Software engineering at the tipping point — original source. Check the original for full context.

Source published:

Key ideas

  • Software development ecosystems are facing an imminent 10x to 15x surge in activity over the next 12 to 18 months, turning code volume into organizational liability unless surrounding engineering practices adapt. (13:26)
  • Code dependency graphs expand quadratically rather than linearly, meaning a 10x increase in codebase size can trigger a 100x to 1,000x explosion in required test compute. (21:35)
  • Autonomous agents treat internal microservice APIs as public interfaces, crawling and invoking unhardened internal endpoints without manual coordination. (26:59)
  • According to DORA research, AI functions strictly as an amplifier of baseline habits: it scales output magnitude without steering direction, multiplying technical debt just as readily as feature velocity. (32:05)

Detailed notes

## Background Published on YouTube by Google for Developers on May 21, 2026, this Google I/O presentation features speaker Adam Bender exploring how systems thinking applies to modern developer ecosystems. According to the session description, the talk aims to help engineers understand how socio-technical environments guide software evolution, build intuition for the systemic impacts of AI-driven development, and prepare for industry-wide shifts.

## TL;DR Adam Bender introduces 'software ecology'—the holistic study of socio-technical ecosystems—to analyze the structural tipping point facing software development in the age of AI. Drawing on Google's 25-year evolution of monorepos, trunk-based development, and 'shared fate,' he demonstrates how an anticipated 10x surge in AI code generation threatens to overwhelm downstream build systems, human code reviews, quadratic test suites, and version control throughput. Because AI acts strictly as an amplifier of an organization's existing engineering fundamentals, simply generating code faster will increase maintenance liability unless teams rethink validation, architectural isolation, and abstraction guardrails. Bender concludes by challenging practitioners to look beyond raw code synthesis and instead harness AI to regain human intellectual control over increasingly complex, unreasoned systems.

## Atmosphere & style The presentation carries the polished, high-energy cadence of a flagship tech keynote, balanced by the candid, battle-tested pragmatism of an experienced systems architect. Bender engages the audience with a conversational delivery, punctuating sobering technical warnings with self-effacing humor—such as admitting that analyzing version control performance means descending into the 'bowels' of developer tooling. The narrative arc moves from an eye-opening reality check on the fragility of current engineering workflows into an inspiring, philosophical call to action, leaving listeners feeling both challenged by the looming operational bottlenecks and empowered to step up as thoughtful stewards of their software ecosystems.

## Bulletin - [13:26](https://www.youtube.com/watch?v=2n41YjR5QfU&t=806s) Software development ecosystems are facing an imminent 10x to 15x surge in activity over the next 12 to 18 months, turning code volume into organizational liability unless surrounding engineering practices adapt. - [21:35](https://www.youtube.com/watch?v=2n41YjR5QfU&t=1295s) Code dependency graphs expand quadratically rather than linearly, meaning a 10x increase in codebase size can trigger a 100x to 1,000x explosion in required test compute. - [26:59](https://www.youtube.com/watch?v=2n41YjR5QfU&t=1619s) Autonomous agents treat internal microservice APIs as public interfaces, crawling and invoking unhardened internal endpoints without manual coordination. - [32:05](https://www.youtube.com/watch?v=2n41YjR5QfU&t=1925s) According to DORA research, AI functions strictly as an amplifier of baseline habits: it scales output magnitude without steering direction, multiplying technical debt just as readily as feature velocity.

## Key takeaways - [03:29](https://www.youtube.com/watch?v=2n41YjR5QfU&t=209s) Software ecology is the holistic study of socio-technical ecosystems—the intersection of human culture, incentives, and technical infrastructure that produces software. - [08:59](https://www.youtube.com/watch?v=2n41YjR5QfU&t=539s) In a high 'shared fate' environment like Google's trunk-based monorepo, a targeted 10-line security patch can propagate across 10 billion lines of code within a week. - [08:59](https://www.youtube.com/watch?v=2n41YjR5QfU&t=539s) Shared fate provides massive leverage in development and integration, but must be deliberately avoided in production topologies to prevent cascading regional outages. - [10:18](https://www.youtube.com/watch?v=2n41YjR5QfU&t=618s) Large Scale Changes (LSCs) enable individual developers to refactor millions of lines of code automatically, functioning as an emergent property of uniform build, test, and code review standards. - [15:34](https://www.youtube.com/watch?v=2n41YjR5QfU&t=934s) Generating source code faster is not engineering faster; as Jeff Atwood noted, 'software is a liability,' so generating 10x more code simply creates 10x more maintenance liability. - [17:35](https://www.youtube.com/watch?v=2n41YjR5QfU&t=1055s) Runaway agentic code creation threatens physical compiler limits with massive binaries, while migrating to microservices merely trades binary bloat for distributed network sprawl. - [19:43](https://www.youtube.com/watch?v=2n41YjR5QfU&t=1183s) Human code review becomes an unworkable bottleneck under 10x code volumes, leading reviewers to cut corners and ultimately eroding human comprehension of system architecture. - [21:35](https://www.youtube.com/watch?v=2n41YjR5QfU&t=1295s) Traditional version control systems prioritize data ordering and consistency over write throughput, making them vulnerable to saturation under high-frequency automated agent commits. - [24:09](https://www.youtube.com/watch?v=2n41YjR5QfU&t=1449s) Relying on a 100% pass rate across millions of automated tests becomes mathematically impossible due to baseline infrastructure flakiness, forcing a shift to statistical validation models. - [25:55](https://www.youtube.com/watch?v=2n41YjR5QfU&t=1555s) Competing autonomous agents can trigger costly 'edit wars,' repeatedly overwriting each other's changes and consuming token budgets without delivering functional progress. - [26:59](https://www.youtube.com/watch?v=2n41YjR5QfU&t=1619s) Accelerated release cadences risk outpacing telemetry detection windows, leaving systems vulnerable to complex rollbacks where multiple conflicting changes are layered over faulty code. - [28:49](https://www.youtube.com/watch?v=2n41YjR5QfU&t=1729s) The 'everyone is a builder' trend fragments shared toolsets into bespoke, siloed apps unless all internal applications write to a standardized common data substrate. - [28:49](https://www.youtube.com/watch?v=2n41YjR5QfU&t=1729s) Entry-level developers can now wield swarms of AI agents with massive blast radiuses, creating an urgent mentorship challenge to build architectural intuition faster. - [30:20](https://www.youtube.com/watch?v=2n41YjR5QfU&t=1820s) Engineering teams must separate temporary practices from permanent principles by repeatedly asking 'Why' to understand legacy decisions and 'What if' to test new constraints. - [33:57](https://www.youtube.com/watch?v=2n41YjR5QfU&t=2037s) Architectural guardrails for AI agents must rest on three pillars: adaptive validation strategies, strict isolation boundaries to protect core revenue services, and robust abstractions that prevent agents from making catastrophic choices. - [35:05](https://www.youtube.com/watch?v=2n41YjR5QfU&t=2105s) Human intellectual control over modern systems is severely degraded, but AI can be redirected from mere code generation to synthesizing telemetry and codebases into interactive architectural models. - [37:03](https://www.youtube.com/watch?v=2n41YjR5QfU&t=2223s) Front-line software engineers must transition from managing individual code 'trees' to stewarding entire systemic 'forests,' using systems thinking to drive organizational standards.

## Detailed walkthrough ### [00:00](https://www.youtube.com/watch?v=2n41YjR5QfU&t=0s) Introduction: Software Ecology and the Tipping Point

Adam Bender takes the stage at Google I/O on a Wednesday afternoon, greeting an energetic audience and acknowledging that the software landscape has shifted dramatically. Looking out at the crowd, he remarks on the rapid pace of change: “Your job in 2026 does not look like what you thought it would in 2020.” He admits that if anyone had attempted to explain modern engineering realities to his 2020 self, he simply would not have believed them. Facing this dizzying evolution, engineers frequently struggle to grasp where all these structural and technical changes are heading.

To make sense of the current moment, Bender introduces the concept of “software ecology,” assuring the audience that it is an established academic and technical discipline rather than a buzzword he made up just to land a speaking slot. While predicting the distant future of technology is impossible, Bender argues that examining current software ecosystems provides clear answers about where artificial intelligence is steering everyday developer workflows: “I think that software ecology, this idea, it gives us the perfect lens for framing this particular moment in our industry.”

[01:34](https://www.youtube.com/watch?v=2n41YjR5QfU&t=94s) Systems, Ecosystems, and Complex Adaptive Systems

Before exploring software ecology directly, Bender lays the foundation through systems thinking. A system, at its most fundamental level, is defined as an interconnected group of elements operating under specific rules to produce a unified whole. Bender illustrates this concept using an everyday mechanism everyone in the room relies upon: an air conditioning unit. A thermostat detects ambient conditions, an HVAC unit modulates output heating or cooling, and the room’s temperature adjusts until the target is met and the signal ceases. For software engineers who design, construct, and maintain systems daily, the foundational rule remains constant: everything within the system is connected.

```mermaid flowchart LR accTitle: Thermostat System Feedback Loop accDescr: A simple feedback loop between a thermostat, HVAC unit, and room temperature. A["Thermostat<br/>(Target Temperature)"] -->|"Controls"| B["HVAC Unit<br/>(Cool / Heat Output)"] B -->|"Adjusts"| C["Room Environment"] C -->|"Feedback Signal"| A ```

An ecosystem represents a specialized, significantly more complex category of system. Bender defines an ecosystem as a dynamic network of interdependent actors that co-evolve with their environment, defined by emergent behavior and decentralized agency. Crucially, the external environment cannot be separated from the actors within it—the environment itself is an integral part of the system. These dynamics qualify ecosystems as Complex Adaptive Systems (CAS), which possess the capacity to learn, adapt, and evolve over time:

> “An emergent property is something that you can't see by looking at any individual piece of the system.”

Because emergent properties materialize only when all constituent parts interact as an integrated whole, tracking cause and effect inside an evolving ecosystem presents an immense analytical challenge.

[03:29](https://www.youtube.com/watch?v=2n41YjR5QfU&t=209s) Socio-Technical Systems and Conway's Law

While the word “ecosystem” typically evokes images of lush, idyllic natural landscapes, an internal developer environment operates under the exact same principles. A developer environment comprises tools, services, business constraints, and opinionated human actors striving to ship software. This makes a developer platform a socio-technical system—a complex hybrid composed of human social dynamics and technical infrastructure.

Bender highlights that most software professionals are already familiar with the foundational mechanics of socio-technical systems through Conway's law. In formal terms, organizations design technological architectures that inevitably mirror their internal communication structures; informally, as Bender quips, if a company assigns four separate teams to build a compiler, they will invariably produce a four-pass compiler. Bender emphasizes that organizational structure is not the sole factor dictating technological outcomes:

> “Your ecosystem builds what your organization incentivizes; your engineering culture creates the environment around your developer ecosystem.”

Socio-technical dynamics govern everything from system architectures and code reviews to postmortems and security policies. Understanding this relationship allows engineering leaders to intentionally align their culture and incentives with desired technical outcomes. Formally summarizing these concepts, Bender defines the central subject of his talk: “Software ecology is the holistic study of the socio-technical ecosystems that produce software.”

[05:43](https://www.youtube.com/watch?v=2n41YjR5QfU&t=343s) Google's Developer Ecosystem and the "Shared Fate" Principle

To ground these abstract principles in concrete reality, Bender examines Google's own developer ecosystem. Developed and refined over twenty-five years, Google's internal environment has scaled into an extraordinarily capable, highly complex platform. Bender provides a disclaimer that his purpose is not to prescribe Google’s exact technical choices to other organizations, noting that every company operates under distinct trade-offs and constraints. When Google published *Software Engineering at Google* (colloquially known internally as the "Flamingo Book"), critics questioned why the first half of the book focused entirely on engineering culture rather than version control or technical tooling:

> “Well, the reality is, if you don't understand the culture that Google has, you can't appreciate why we have the technical choices that we've made.”

Google's culture and tooling function as inseparable halves of a single socio-technical organism. Culturally, the company prioritizes engineering leadership, transparency across documentation and code, helpfulness among peers, blameless postmortems, continuous improvement, and the principle that sustainability and automated tooling must always supersede individual heroics and operational toil. On the technical side, Google supports these cultural ideals with an uncompromisingly standardized infrastructure:

- **Monolithic Repository:** A unified monorepo housing the organization’s code. - **Trunk-Based Development:** Every engineer commits directly to head across all changes. - **Source Compilation:** Almost every binary artifact inside Google is compiled directly from source. - **Universal Toolchain:** A single, standardized build system used company-wide. - **Global Test Automation:** A centralized testing platform running billions of automated tests daily. - **Global Signal for Last Green:** A unified internal dashboard displaying the precise state of any build. - **Uniform Compute Environments:** Standardized environments that eliminate "works on my machine" discrepancies. - **Opinionated Frameworks & Constrained Languages:** Strict adherence to a small, curated set of core programming languages and frameworks.

Tying Google’s technical architecture directly back to its organizational culture, Bender highlights the single guiding principle underlying the entire ecosystem: “shared fate.” In a high shared-fate ecosystem, components are so deeply and deliberately interconnected that an event or change in one part of the system immediately impacts all others.

[08:59](https://www.youtube.com/watch?v=2n41YjR5QfU&t=539s) Shared Fate and Monolithic Repositories

Adam Bender emphasizes that creating shared fate within an organization is not merely a technical decision; it requires deliberate social contracts to dictate how teams manage shared tools and assets. At Google, this philosophy centers on their massive monolithic repository. Aside from a few notable exceptions such as Android and Chrome, every single line of code across the company lives in one shared repository. There are no long-lived branches and no independent version branches—everything is committed straight to trunk.

```mermaid flowchart TD accTitle: Monorepo Shared Fate Architecture accDescr: Diagram illustrating how a single patch in Google's monorepo propagates to all applications while avoiding production cascading failures.

subgraph Development["Development Monorepo (Shared Fate)"] Patch["Security Patch\n(10 lines of code)"] Trunk["Single Trunk\n(No branches or versions)"] Apps["10 Billion Lines of Code\n(All company applications)"] Patch --> Trunk Trunk -->|"Auto-propagates within 1 week"| Apps end

subgraph Production["Production Environment (Fault Isolation)"] S1["Service A"] S2["Service B"] C1["Cluster 1"] C2["Cluster 2"] S1 -.->|"Isolated from"| S2 C1 -.->|"Prevents cascade to"| C2 end ```

This structural choice gives the engineering organization an operational superpower: an engineer can apply a critical security fix in a single file of roughly ten lines of code, and within a week, that change will have propagated across ten billion lines of application and system software. However, Bender cautions that shared fate is fundamentally a design trade-off rather than an absolute good. While shared fate works wonders in code storage and integration, it is actively avoided in production infrastructure. Google intentionally isolates services and clusters so that an outage in one service cannot cause cascading failures across entire regions.

- With rare exceptions like Android and Chrome, all Google code resides in a single trunk-based monorepo without branching or distinct versioning. - Ten lines of targeted code in the repository can seamlessly patch ten billion lines of running software within seven days. - Shared fate is avoided in production topologies to ensure that a single service failure or cluster defect cannot trigger wider regional cascading outages.

> “10 lines of code in the right place can patch 10 billion lines of application and system software.” — Adam Bender

---

[10:18](https://www.youtube.com/watch?v=2n41YjR5QfU&t=618s) Large Scale Changes (LSCs) as an Emergent Property

When an ecosystem embraces a monorepo and shared fate, emergent capabilities arise that go far beyond standard developer workflows. The prime example at Google is the concept of Large Scale Changes (LSCs). For at least fifteen years—well before modern artificial intelligence—Google built internal tooling that allows a solitary developer to modify millions of lines of code across thousands of projects automatically. The author of an LSC will often never inspect, review, or touch the vast majority of the code they alter, yet these systems enable the entire monorepo to modernize frameworks, refactor APIs, and upgrade languages continuously without stagnating.

Bender points out that you cannot simply build an LSC tool in isolation; the mechanism relies entirely on an intertwined cultural and technical ecosystem. An LSC cannot function without a universal, rigorous testing culture where developers write dependable tests and report results to a centralized, discoverable platform. It also demands standardized build systems (guaranteeing deterministic, reproducible outputs across machines), unified libraries, standard code review processes, and radical transparency across the repository so engineers can find every call site that needs updating. LSCs represent the ultimate expression of Google’s cultural mandate: prioritizing automation over toil.

- Google has executed automated Large Scale Changes across millions of lines of code for over 15 years without relying on AI. - LSCs require an interconnected ecosystem: comprehensive testing, a unified test result platform, standardized build tools, common libraries, uniform code reviews, and complete source visibility. - SRE and developer tooling teams maintaining these systems function as the company's unsung heroes, enabling continuous codebase modernization.

> “LSCs are truly the ultimate manifestation of this automation over toil ethos at Google.” — Adam Bender

---

[11:57](https://www.youtube.com/watch?v=2n41YjR5QfU&t=717s) Ecosystem Trade-offs and Organizational Values

Every engineering ecosystem develops its own emergent properties based on the unique constellation of choices it makes. Google has optimized its environment for extreme scale, security, and raw performance, and it is explicitly willing to sacrifice individual developer productivity in specific scenarios to protect those core qualities. In contrast, a five-person startup will inevitably choose a starkly different balance, prioritizing raw velocity, agility, and rapid iteration above all else.

Most software teams operate somewhere along the spectrum between a five-person startup and a 200,000-person enterprise. Bender explains that analyzing where an organization draws these technical trade-offs exposes what it genuinely values, as opposed to what it merely claims to value in mission statements. Understanding these embedded values is critical for engineers who must guide their systems through modern disruptions rather than just passively reacting to them.

- Trade-offs uncover an organization's true operational values rather than its stated ideals. - Google consciously prioritizes scale, security, and performance over individual developer ergonomics when conflicts occur. - A small startup optimizes almost exclusively for velocity and agility to survive.

> “The trade-offs you're going to make are really important to pay attention to, because when you look at the trade-offs being made, you can begin to understand the values of the organization.” — Adam Bender

---

[13:26](https://www.youtube.com/watch?v=2n41YjR5QfU&t=806s) The Token-Eating Elephant and the 10x Shockwave

Bender transitions to the central challenge facing software development: “the token-eating elephant in the room”—the shift toward an AI-first developer ecosystem. While creating an AI-native ecosystem from scratch on a greenfield project would be ideal, virtually no practicing engineer has that luxury. Instead, teams must swap out core components of their software delivery engine mid-flight without breaking production or interrupting their business commitments.

To navigate this migration, engineers must rigorously audit their existing ecosystems across both social and technical dimensions: identifying bottlenecks, dependencies, testing constraints, and areas of architectural freedom. Bender issues an urgent challenge: if development activity surges by 10x to 15x over the next 12 to 18 months, do teams know what will break first? With industry leaders predicting 10x to 100x leaps in raw output, organizations face an imminent “code red” moment requiring them to re-evaluate the trade-offs they have cultivated over the past 25 years.

- Teams must replace their developer ecosystems incrementally while continuing to deliver customer value and maintain uptime. - Current ecosystems will likely experience an influx of 10x to 15x more activity within the next 12 to 18 months. - Engineering leadership must identify their system bottlenecks and structural limits before extreme volume breaks their workflows.

> “And perhaps most importantly, if your ecosystem suddenly had to grow by, I don't know, 10 to 15x in the next 18 months, do you know what would break first?” — Adam Bender

---

[15:34](https://www.youtube.com/watch?v=2n41YjR5QfU&t=934s) Code Generation vs. Engineering: The Impact of 10x Code

Bender clarifies a fundamental distinction: generating raw source code ten times faster is completely different from engineering ten times faster. Quoting an adage popular inside Google, he notes that engineering is best understood as “programming integrated over time.” While AI accelerators and Large Language Models are drastically speeding up the raw programming phase—the “code machine”—the surrounding disciplines of architecture, testing, maintenance, and operations must be re-engineered to handle that output.

```mermaid flowchart LR accTitle: Code Generation Velocity Versus Maintenance Liability accDescr: Pipeline showing how increased code generation leads to higher system liability and longer compile times.

subgraph Upstream["Upstream Input"] AI["AI Code Acceleration\n(Tokens / Prompts)"] Speed["10x Source Code Velocity"] AI --> Speed end

subgraph Pipeline["Ingestion & Build"] Repo["Repository Intake"] Build["Build Systems\n(Longer compile times)"] Speed --> Repo Repo --> Build end

subgraph Downstream["System Impact"] Liability["10x Code Volume =\n10x Maintenance Liability"] Build --> Liability end ```

Relying on an old maxim from Jeff Atwood, Bender warns that “software is a liability.” Consequently, generating ten times as much source code simply produces ten times more organizational liability. Handing developers API tokens without retraining, updated documentation, and revamped engineering practices will cause the delivery pipeline to buckle. The immediate downstream casualty of this influx is the build system itself, where raw code volume directly inflates compilation times and strains integration infrastructure.

- Google defines software engineering as “programming integrated over time,” separating short-term coding from long-term sustainability. - Faster code generation introduces systemic risk unless surrounding engineering practices adapt to the increased volume. - Simply distributing tokens without retraining staff or updating documented engineering practices creates unmanageable technical debt. - Expanding codebase sizes immediately degrades build systems through inflated compilation times.

> “Software is a liability. So right off the bat, 10x more code, 10x more liability.” — Adam Bender (quoting Jeff Atwood)

[17:35](https://www.youtube.com/watch?v=2n41YjR5QfU&t=1055s) The Looming Crisis of Compilation and Architectural Sprawl

As AI agents begin driving code creation, software systems inevitably balloon in size and change frequency. Adam Bender jokes that while developer organizations already complain constantly about sluggish build times, the situation is poised to deteriorate dramatically: compilation will not only take longer due to massive binaries, but agents will trigger compiles continuously throughout the day. Compilation costs real compute and developer time, and while engineers might take their existing build cycles for granted, scaling the codebase by an order of magnitude will make compile latency an unavoidable tax. Beyond compile time, architectural design becomes deeply precarious. Bender raises critical questions about whether engineering teams possess the right agentic skills to guide decoupling, or the right server frameworks to safely compose capabilities when developers cannot even account for how many different web server frameworks are already running across their organizations today.

```mermaid flowchart TD accTitle: The Cascade of Scale in Agentic Software Engineering accDescr: Diagram illustrating how 10x code generation cascades into build bloat, reviewer burnout, quadratic test inflation, and version control limits.

subgraph Gen ["1. Code Generation"] A["Agentic Code Generation<br/>(10x Velocity)"] end

subgraph DevTax ["2. Developer Infrastructure Pressure"] B["Massive Binaries &<br/>Runaway Compile Times"] C["Human Review Bottleneck<br/>(Corner-cutting & Ignorance)"] end

subgraph ScaleTax ["3. Downstream Capacity Limits"] D["Quadratic Test Explosion<br/>(100x to 1000x Compute)"] E["VCS Write Saturation<br/>(Commits/Minute Limits)"] end

A --> B A --> C B --> D C --> E D --> E ```

The fundamental tension lies in how agents produce artifacts. Currently, models excel at generating code that is easy to produce but disproportionately difficult for human engineers to maintain, lacking the long-term, well-factored design sensibilities that sustainable systems demand. Left unchecked, this agentic output threatens physical limits: binaries can grow so large that compilers can no longer link them or mobile operating systems can no longer ship them. Bender shares that Google itself is bumping up against these exact boundaries in certain environments where binaries are becoming too vast to build. For teams assuming they can sidestep this by adopting microservices, Bender warns that microservices merely trade binary bulk for network sprawl: a tenfold increase in services brings a tenfold increase in network chatter and distributed failure modes.

> “Agents are good at writing code, but they're not always thinking long term the same way you and I need to.” — Adam Bender

- In Google's own engineering ecosystem, certain binaries are growing so large that compilers are hitting operational limits. - Opting for microservices does not dodge the scaling wall; it trades binary size for a 10x explosion in network traffic, service count, and inter-service chatter. - As Bender cautions engineers attempting to escape the fallout: “No one gets out of this unscathed. Scale has effects everywhere.”

---

[19:43](https://www.youtube.com/watch?v=2n41YjR5QfU&t=1183s) Human Bottlenecks in Code Review and Token Economics

Code review represents a fragile human process under unprecedented strain. When developers leverage AI to generate ten times more code, teams face an immediate arithmetic dilemma: they must either review changes that are ten times larger, or evaluate ten times as many pull requests. Tech leads simply cannot sustain the velocity required to supervise even five such amplified developers in a single workday. Because humans instinctively despise feeling like the bottleneck, reviewers inevitably adapt by altering their behavior and cutting corners, skimming diffs and stamping approvals just to keep the assembly line moving.

Deploying AI to assist in code review offers only partial relief. If software engineers stop writing code by hand, their only touchpoint with the codebase occurs during code review. If engineers simultaneously stop paying close attention during review to avoid blocking velocity, nobody is actively monitoring or understanding the evolving architecture. The predictable outcome is an unmaintainable codebase that has outpaced all human comprehension. Alongside this structural rot, organizations must confront token economics: unchecked agent invocations present direct financial liabilities. Bender relates an anecdote of an acquaintance who accidentally incinerated an entire monthly token budget in a single day, highlighting how few engineering organizations possess the basic telemetry needed to track, let alone prioritize, where their token expenditures are bleeding out.

> “Pretty soon, your code base is going to be a mess that no one can understand.” — Adam Bender

- Reviewers under pressure will actively cut corners and lower scrutiny to avoid blocking colleagues. - Relying on AI for both generation and review eliminates meaningful human oversight, leaving no one with a mental model of the software as it evolves. - Token consumption scales into an existential budget item; teams currently lack granular visibility into which systems or developers consume their model spend.

---

[21:35](https://www.youtube.com/watch?v=2n41YjR5QfU&t=1295s) Quadratic Test Expansion and Version Control Performance Limits

Testing and version control constitute the foundational plumbing of developer operations, yet both are ill-prepared for an agentic surge. Agents rely heavily on test suites to provide feedback loops on their progress, creating an insatiable appetite for test compute. Compounding the issue is an architectural reality discovered at Google: dependency graphs do not scale linearly with codebase size, but quadratically. Consequently, expanding a codebase by 10x can easily trigger a 100x or even 1,000x explosion in the number of tests required to validate dependency trees. Bender points out that organizations unconcerned about their test compute budget are likely in a worse predicament, as it indicates they lack sufficient automated tests—allowing unsupervised agents to make unchecked changes across their repositories.

Even if an organization resolves compilation and testing compute bottlenecks, the version control system (VCS) itself becomes a choking point. Mainstream VCS platforms like Git were historically engineered around data consistency, cryptographic hashing, and strict chronological ordering rather than high-throughput write performance. They struggle to ingest high-frequency automated commit volumes per minute. Bender laments that having to evaluate the raw ingest performance of a version control system means developers have descended into the absolute "bowels" of developer tooling. Furthermore, attempting to bypass VCS limits by dividing systems into thousands of micro-repositories merely introduces an entirely new, agonizing set of dependency and orchestration problems that AI does not solve.

> “Honestly, if we're talking about version control performance, something has gone horribly wrong. We are in the bowels of the developer experience here, the bowels.” — Adam Bender

- Dependency graphs scale quadratically rather than linearly relative to codebase size, meaning 10x code growth translates to 100x to 1,000x the test executions. - Standard version control systems prioritize ordering and record consistency over ingestion throughput, making them vulnerable to saturation under agentic commit rates. - Dividing monolithic codebases into thousands of micro-repositories trades VCS throughput problems for distributed dependency management nightmares.

---

[24:09](https://www.youtube.com/watch?v=2n41YjR5QfU&t=1449s) Beyond Capacity: Integration Testing, Statistical Gates, and Massive Merge Conflicts

The issues discussed so far represent merely the straightforward "capacity nodes"—problems that can be anticipated simply by multiplying an existing metric by ten. A deeper set of qualitative, systemic challenges lurks beyond simple compute capacity. First among these is validation: while organizations rely primarily on unit tests with a smattering of integration tests, scaling code and services by an order of magnitude shifts the entire burden of quality onto integration testing. Bender surveys the Google I/O audience to ask if anyone is genuinely satisfied with their integration testing setup, observing for the livestream that not a single hand was raised. Integration testing remains notoriously difficult, fragile, and starved of adequate tooling.

This leads to what Bender terms the "conjunction of Booleans." Historically, shipping software requires an absolute standard: every single test must evaluate to true (a sea of green checkmarks). In a world where systems execute millions of tests, the physical reliability of the underlying test infrastructure itself guarantees occasional random failures, flakes, or timeouts. When running a million tests, insisting that every single Boolean gate evaluates to true makes shipping software mathematically impossible. As a result, engineering ecosystems must abandon absolute Boolean gates in favor of statistical testing models that infer quality from probabilistic subsets of tests.

Finally, because agents empower any engineer to execute sweeping, repository-wide refactors and language migrations, teams face unprecedented diff sizes. Engineering social contracts and merge workflows are completely unequipped to resolve merge conflicts spanning hundreds of thousands or millions of lines of code as massive parallel changes collide—a dynamic setting the stage for chaotic agentic edit wars.

> “It might not be possible to ship software where every Boolean has to be true.” — Adam Bender

- Integration testing becomes the primary determinant of quality in hyper-scaled, multi-service ecosystems, yet current tooling leaves engineering teams broadly dissatisfied. - Demanding a 100% pass rate across millions of tests fails due to baseline infrastructure flakiness, necessitating a shift toward statistical and risk-weighted testing strategies. - Automated refactorings routinely generate change sets containing tens of thousands to millions of lines of code, breaking existing human merge and conflict-resolution workflows.

[25:55](https://www.youtube.com/watch?v=2n41YjR5QfU&t=1555s) Agent Edit Wars and the Dilemma of Release Velocity

When autonomous agents interact in an uncoordinated development loop, unexpected dysfunctions emerge almost immediately. One agent generates a code change, only for a secondary agent to evaluate it, disagree, and overwrite it with an entirely different implementation. While watching two models argue over code diffs can seem amusing at first glance, the economics make it painful: engineering organizations end up footing the bill for the model tokens consumed on both ends of the dispute.

```mermaid flowchart TD accTitle: The Deployment Cadence Dilemma accDescr: Shows the trade-off between release batch size, frequency, and risk under 10x code generation.

subgraph Generation["Code Generation"] A["10x Code Volume from Agents"] end

subgraph ReleaseChoice["Release Strategy Dilemma"] B["Infrequent Releases"] --> C["Massive Batch Sizes<br/>High SRE Risk"] D["Hyper-Frequent Releases<br/>(e.g., Every Second)"] --> E["Diminishing Returns<br/>Detection Lags"] F["Target Cadence<br/>(Balanced Daily/Sub-Daily)"] --> G["Manageable Batch Size<br/>Stable Risk Profile"] end

A --> B A --> D A --> F ```

This influx of synthetic code puts severe pressure on release pipelines. As engineering velocity scales up to ten times the previous software output, that software must eventually land in production to deliver value. Organizations not currently releasing on a daily cadence will see pull request sizes balloon into massive, high-risk batches. Adam Bender points out that this directly clashes with site reliability principles: “And if there's one thing my SRE friends will tell me, it is that very large changes are very scary.” While pushing deployment frequency higher aligns with guidance from DORA (DevOps Research and Assessment), extreme cadences encounter sharp diminishing returns. Deploying every single second creates chaos rather than value, forcing teams to strike a careful balance between manageable batch sizes and sustainable deployment intervals.

- **Agent churn cost:** Competing agents overwriting one another consume token budgets simultaneously without advancing functional work. - **Batch size inflation:** Teams unable to support daily releases will see individual deployment payloads expand dangerously under 10x generation volumes. - **Cadence limits:** The ideal deployment frequency exists in the sweet spot between once a day and continuous sub-second deployments.

---

[26:59](https://www.youtube.com/watch?v=2n41YjR5QfU&t=1619s) Internal APIs, Jevons Paradox, and Fragile Rollback Dynamics

The surge of AI agents alters the assumptions underpinning internal infrastructure and system boundaries. Internal data layers and microservice interfaces can no longer rely on implicit trust or organizational obscurity. Adam Bender warns that these boundaries have dissolved entirely: “What I've been telling my friends that I work with is, all of your APIs suddenly just became public.” Autonomous agents will systematically discover, crawl, and invoke any reachable endpoint to acquire data, meaning internal services require the exact same access control, validation, and defensive hardening typically reserved for public, internet-facing endpoints.

```mermaid flowchart LR accTitle: Rollback Safety Race Condition accDescr: Contrasts traditional safe rollbacks against rapid release rollbacks that outpace detection.

subgraph Traditional["Traditional Rollback Buffer"] T1["Deploy Change"] --> T2["Production Monitoring"] T2 -->|"Detect Issue"| T3["Clean Rollback<br/>(Single Delta)"] end

subgraph FastPaced["Hyper-Accelerated Cadence"] F1["Deploy A"] --> F2["Deploy B"] F2 --> F3["Deploy C"] F3 -.->|"Delayed Detection of A"| F4["Conflicting Rollback<br/>(Multiple Interleaved Deltas)"] end ```

Simultaneously, the industry is experiencing Jevons paradox: as the marginal cost of compute and intelligence drops, usage expands exponentially rather than contracting. Teams insert token-based workflows into critical operational paths, occasionally introducing brittle dependencies where failure modes are severe. If an incident response or rollback automation depends on an agent whose token quota has been exhausted, recovery halts. Furthermore, modern rollback mechanics depend fundamentally on a temporal safety margin: systems rely on releasing software slightly slower than the time required for telemetry to detect regressions. When deployment cadence outpaces mean time to detect (MTTD), any rollback must untangle multiple conflicting changes deployed on top of the faulty version.

- **API hardening:** Internal enterprise APIs must adopt public-perimeter security models because autonomous agents discover and scrape internal interfaces without manual coordination. - **Jevons paradox:** Plunging inference costs lead to pervasive token consumption, making previously implicit productivity costs explicit line items. - **Rollback dependency risks:** Embedding token-consuming agents into operational recovery loops introduces critical failure points if token allowances expire during an outage. - **Detection latency gap:** Deploying faster than telemetry can identify anomalies creates tangled rollback states with stacked, inter-dependent changes.

---

[28:49](https://www.youtube.com/watch?v=2n41YjR5QfU&t=1729s) The "Everyone's a Builder" Fallacy and the Developer Experience Gap

The democratization of software development—often summarized by the premise that “everyone is a builder”—creates subtle organizational risks alongside its productivity benefits. When anyone across an enterprise can rapidly vibe-code bespoke replacements for internal tooling they dislike, the shared tooling baseline fractures. Without a single, robust data substrate holding everything together, internal collaboration deteriorates as disparate teams silo themselves inside custom, incompatible applications. Adam Bender summarizes the hidden maintenance burden of widespread generation: “Everyone's a builder is cool, until you have to maintain all the stuff that everyone built.”

```mermaid flowchart TD accTitle: The Mentorship Blast Radius Mismatch accDescr: Illustrates the gap between junior developer judgment and the blast radius of orchestrating 50 agents.

subgraph JuniorContext["Junior Developer Capability"] A["New Engineer"] --> B["50 Orchestrated Agents"] B --> C["Massive Code Output"] end

subgraph BlastRadiusGap["The Judgment Deficit"] C --> D{"Blast Radius Analysis"} D -->|"Requires Intuition & Experience"| E["Systemic Production Impact"] A -.->|"Lacks 10 Years of Pattern Recognition"| D end ```

This proliferation of generative tooling also strains mentorship and career progression. Historically, engineers spent years developing architectural taste, intuition, and failure pattern recognition before being trusted with high-impact technical leadership roles. Today, entry-level engineers can immediately command swarms of dozens of agents, wielding massive technical leverage without the corresponding judgment to evaluate systemic consequences. Furthermore, human cognitive bandwidth remains strictly finite. As the sheer volume of synthetic code, review requests, and agent notifications grows, attentional overhead becomes the primary constraint on software engineering.

- **Siloed internal tooling:** Unchecked tool generation erodes company cohesion unless all bespoke applications write to a standardized common data substrate. - **The mentorship dilemma:** Engineering organizations face the unsolved pedagogical problem of condensing ten years of technical intuition into months to safely govern agent-assisted juniors. - **Cognitive exhaustion:** Human attention is the ultimate bottleneck; developers can no longer rely on manual friction to limit the number of simultaneous issues demanding review.

---

[30:20](https://www.youtube.com/watch?v=2n41YjR5QfU&t=1820s) Applying Systems Thinking: The Power of "Why" and "What If"

Navigating agentic development requires moving beyond isolated optimizations to embrace holistic systems thinking. In highly coupled technical ecosystems, optimizing an isolated node—such as speeding up code synthesis—frequently creates compounding bottlenecks in adjacent testing, review, and deployment pipelines. Evaluating these architectures requires interrogating directional causality, feedback loops, node interconnectedness, technical and social incentives, and emergent properties that arise without explicit design.

To make systems analysis actionable, engineering organizations can anchor their inquiries on two straightforward questions: *Why* and *What if?* The question *Why* acts as an investigative drill, penetrating entrenched institutional habits to understand why testing topologies, language choices, or deployment gates were initially constructed. Conversely, *What if* challenges those foundational constraints, inviting teams to reimagine architectures free from legacy assumptions. Adam Bender underscores the psychological weight of this inquiry: “'What if' can be scary, if we're asking you to abandon the practices you thought were really well-designed for the problems that you had.”

- **Key systems lenses:** - **Scale and emergence:** Unintended behaviors surfacing from the interaction of localized agent routines. - **Incentive structures:** Aligning both social developer habits and automated technical constraints. - **Bottleneck identification:** Locating where amplified upstream throughput overwhelms downstream capacity. - **The "Why" inquiry:** Deconstructs legacy decisions (e.g., *Why do integration tests run far less frequently than unit tests?*). - **The "What If" inquiry:** Reevaluates foundational operating principles (e.g., *What if test synthesis outpaces manual authoring entirely?*).

---

[32:05](https://www.youtube.com/watch?v=2n41YjR5QfU&t=1925s) AI as an Amplifier and Core Fundamentals for the Road to 2030

Citing research from DORA, Adam Bender highlights an essential operational truth: generative AI acts fundamentally as an amplifier rather than a self-directed cure for organizational deficiencies. Because amplification scales magnitude rather than dictating direction, applying AI to an engineering organization multiplies whatever baseline patterns already exist. Teams with rigorous code health, disciplined release hygiene, clear technical strategies, and cohesive decision-making see their productivity expand. Conversely, teams plagued by broken feedback loops, poor security hygiene, or communication silos simply generate higher volumes of debt, bugs, and confusion.

```mermaid flowchart LR accTitle: AI as an Amplifier of Fundamentals accDescr: Shows how AI magnifies good engineering foundations into velocity and poor foundations into technical debt.

AI["AI Amplification Engine<br/>(Magnitude Without Direction)"]

subgraph SolidBase["Solid Engineering Fundamentals"] G1["High Code Health"] G2["Disciplined Release Hygiene"] G3["Clear Security Posture"] end

subgraph WeakBase["Compromised Fundamentals"] W1["Fragmented Architecture"] W2["Opaque Rollback Paths"] W3["Poor Communication"] end

SolidBase --> AI --> OutGood["Accelerated Delivery & Reliability"] WeakBase --> AI --> OutBad["Compounded Churn, Regressions & Confusion"] ```

Adam Bender captures this reality plainly: “AI doesn't solve any of these problems for you, by default. It can amplify the practices you have, if they're good. But if they're not good, it's going to cause more trouble.” Looking ahead, he predicts that the developer ecosystems of 2026 will appear as distant to practitioners in 2030 as the CD-ROM shipping workflows of 2001 look today. Preparing for that transition requires doubling down on the essentials: mastering infrastructure capacity tracking so compute expenditures remain bounded, and establishing rock-solid validation mechanisms to ensure unverified synthetic software never makes it into production.

- **Amplification mechanics:** AI increases output volume unconditionally; without strategic guidance, it accelerates technical dysfunction just as readily as feature delivery. - **Critical organizational foundations:** - Decision-making frameworks and collaborative alignment. - Objective metrics for developer productivity and code health. - Robust release hygiene, site reliability practices, and defensive security posture. - **The 2030 horizon:** The shift in tooling and workflows over the coming years will mirror the historic leap from early-2000s physical media distribution to modern cloud software. - **Non-negotiable pillars:** Maintaining clear real-time visibility into infrastructure capacity limits and deploying exhaustive validation barriers before any code ships.

[33:57](https://www.youtube.com/watch?v=2n41YjR5QfU&t=2037s) Validation, Isolation, and Abstraction for AI Agents

Adam Bender explains that as software development shifts, engineers must proactively prepare three core pillars: validation, isolation, and abstraction. Because validation is fundamentally transforming, teams need an intentional validation strategy right now. Isolation is equally critical because developers are about to generate a massive amount of code for novel use cases that were never addressed with code previously. While rapid prototyping is fine, experimental code cannot be allowed to leak into mission-critical systems: engineers must ensure the fun prototype stuff does not break or impact the money-making stuff. Finally, abstraction is vital because abstractions have always existed to protect developers from making catastrophic choices—just as modern engineers rely on established frameworks rather than writing a web server from scratch. Giving autonomous AI agents an unconstrained decision space carries the exact same risks. As Adam Bender warns, “So we need good abstractions for the agents to hold on to. Don't give them bad choices.”

```mermaid flowchart TD accTitle: Architectural Guardrails for AI Development accDescr: Three essential pillars needed when integrating AI agents into software codebases. subgraph Guardrails["Architectural Guardrails"] V["Validation Strategy<br/>(Adapt to changing paradigms)"] I["Isolation Boundaries<br/>(Keep prototype code out of production)"] A["Robust Abstractions<br/>(Prevent agents from making bad choices)"] end Agents["AI Agents & Generated Code"] --> Guardrails Guardrails --> Prod["Reliable Production Systems"] ```

Beyond tooling, engineers must confront the reality that long-held engineering practices are not sacred. Practices naturally change over time, whereas underlying principles endure. While separating the two is difficult—especially when entrenched routines like automated testing or specific release pipelines start to feel like fundamental principles—teams must dig into first principles. Without understanding *why* a team tests software or operates its release processes the way it does, it will be impossible to adapt those practices. Grasping the foundational principles is what equips teams with the confidence and power to navigate the disruptive "10x moment."

[35:05](https://www.youtube.com/watch?v=2n41YjR5QfU&t=2105s) Intellectual Control and Using AI to Understand Systems

The present moment is an exhilarating time to be a software engineer, as every single dimension of the discipline is undergoing redefinition. Rather than succumbing to the temptation to prematurely optimize everything, engineers need to flex their creative muscles and explore emerging challenges such as context management, token economics, and model drift. Bender shares a profound problem that has been keeping him up at night that cannot be resolved through sheer optimization: preserving human intellectual control over sprawling codebases as they expand. Defining the term candidly, Adam Bender notes, “Intellectual control, by the way, is just a fancy way of saying, can humans reason about this thing in front of them?”

The software industry has arguably been losing this battle for at least the past 15 years, with modern enterprise architectures far exceeding the cognitive capacity of any single human mind. To prove this point, Bender suggests a simple experiment: go back to your team on Monday and ask every engineer to sketch an architecture diagram of your system from memory, and observe how many completely conflicting pictures emerge. Our systems are exceptionally brittle—a million-line codebase can be brought down by a single bad line of code or an erroneous configuration flag, breeding an environment of fear where engineers hesitate to touch core components.

```mermaid flowchart LR accTitle: Interactive Architectural AI Model accDescr: Using AI to build an interactive architectural model that answers complex system-wide queries. subgraph Inputs["System Reality"] Code["Codebases"] Configs["Configurations"] Telemetry["Runtime Telemetry"] end Inputs --> AI["AI Synthesis Engine"] AI --> Model["Interactive Architectural Space"] Model --> Q1["'Shift capacity to East Coast?'"] Model --> Q2["'User growth jumps 40%?'"] ```

However, AI presents an unprecedented opportunity to regain systemic comprehension rather than merely serving as an automated code generator: - AI can synthesize massive, complex operational datasets into a continuously updated, interactive architectural space that engineers can interrogate directly. - Teams could pose hypothetical operational scenarios that are functionally impossible to calculate today, such as modeling the exact cascading effects of shifting capacity over to the East Coast. - Engineers could simulate systemic bottlenecks if user growth suddenly spiked by 40%. - Instead of exclusively focusing on accelerating the code generation machine, engineers can harness AI to radically deepen their comprehension of the vast systems they have already built.

[37:03](https://www.youtube.com/watch?v=2n41YjR5QfU&t=2223s) Mentorship, Advocacy, and Seeing the Forest for the Trees

Given the blistering velocity of industry change—faster than almost anyone has witnessed in their careers—Bender urges engineers to actively support colleagues who feel overwhelmed or stuck. Senior engineers must step up as mentors, and anyone who has developed an effective AI developer workflow should openly share it rather than guarding it as a precious secret. Technical leads must take an active role in steering organizational engineering standards. Most importantly, practitioners who care deeply about software design and software quality must make their voices heard, because executive leadership will not fight that battle for them.

Drawing on an ecological metaphor, Bender reflects that developers have historically spent their careers hyper-focused on inspecting every individual leaf on every branch, treating every single tree as an isolated, precious specimen. Soon, however, developers will be tasked with stewarding entire forests:

> “And you can't manage a forest by looking at individual trees. You have to manage a forest by seeing it as an ecosystem.”

Systemic transformations often feel terrifying because they seem to happen to everything, everywhere, all at once, making individuals feel powerless against the weekly onslaught of industry disruption. Yet systems thinking proves that all components are deeply interconnected, meaning small, localized actions exert enormous leverage. Executive leadership alone does not dictate the AI transformation; front-line engineers occupy the critical vantage point deciding what software engineering will become. By understanding systemic leverage points across their tools, workflows, practices, and team cultures, engineers possess far more agency than they realize to shape the future of their teams, their organizations, and themselves.

## Notable quotes > [03:29](https://www.youtube.com/watch?v=2n41YjR5QfU&t=209s) Your ecosystem builds what your organization incentivizes; your engineering culture creates the environment around your developer ecosystem. — Adam Bender

> [08:59](https://www.youtube.com/watch?v=2n41YjR5QfU&t=539s) 10 lines of code in the right place can patch 10 billion lines of application and system software. — Adam Bender

> [17:35](https://www.youtube.com/watch?v=2n41YjR5QfU&t=1055s) Agents are good at writing code, but they're not always thinking long term the same way you and I need to. — Adam Bender

> [24:09](https://www.youtube.com/watch?v=2n41YjR5QfU&t=1449s) It might not be possible to ship software where every Boolean has to be true. — Adam Bender

> [11:57](https://www.youtube.com/watch?v=2n41YjR5QfU&t=717s) The trade-offs you're going to make are really important to pay attention to, because when you look at the trade-offs being made, you can begin to understand the values of the organization. — Adam Bender

> [35:05](https://www.youtube.com/watch?v=2n41YjR5QfU&t=2105s) Intellectual control, by the way, is just a fancy way of saying, can humans reason about this thing in front of them? — Adam Bender

## Mentioned Adam Bender, Google, Google I/O 2026, Google for Developers, Conway's law, Software Engineering at Google, Android, Chrome, Jeff Atwood, Git, DORA

## Video description Learn to use systems thinking to understand how developer ecosystems guide the evolution of your software systems. Improve your intuition for the systemic impacts of AI-driven software development and understand how you can better prepare for the exciting changes coming to our industry.

Speakers: Adam Bender

Watch the Professional Development sessions from Google I/O 2026 → https://goo.gle/professional-developement-IO26

Subscribe to Google for Developers → https://goo.gle/developers

#GoogleIO

Event: Google I/O 2026

Products Mentioned: AI/Machine Learning, Cloud

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

Reading summary

Adam Bender argues that software engineering has reached a tipping point driven by artificial intelligence, requiring organizations to evaluate their socio-technical ecosystems rather than merely accelerating raw code generation. Because AI amplifies baseline engineering practices without fixing structural deficiencies, teams must redesign validation, capacity, and architectural abstractions to prevent delivery pipelines from collapsing. Software Ecology and Socio-Technical Ecosystems (3:29) Bender defines software ecology as the holistic study of the socio-technical ecosystems that produce software. Developer platforms are complex adaptive systems where technical tools, business constraints, and human social incentives continuously co-evolve, reflecting Conway's law. What an organization incentivizes determines what its technical architecture builds. Shared Fate and Google's Architectural Trade-offs (5:43) At Google, this socio-technical dynamic centers on the principle of "shared fate," anchored by a monolithic trunk-based repository. A ten-line security patch committed to trunk can automatically propagate across ten billion lines of code within seven days. This shared fate enabled automated Large Scale Changes (LSCs) across thousands of projects for fifteen years before AI, though Google explicitly avoids shared fate in production to prevent regional cascading failures. Bender stresses that all technical architectures reflect organizational trade-offs: Google trades individual developer ergonomics for scale, security, and performance, whereas early-stage startups prioritize raw velocity. The 10x Bottleneck: Downstream Delivery Collapse (15:34) Accelerating raw code generation by 10x does not equate to engineering 10x faster. Citing the adage that software is a liability, Bender warns that multiplying code output ten times simply multiplies maintenance liability. With industry leaders projecting 10x to 15x activity leaps within 12 to 18 months, downstream infrastructure faces immediate saturation. Compilation times inflate from massive binaries, while microservices merely replace binary bulk with network chatter and distributed failures. Under this volume, human tech leads cannot review multiplied diffs, leading reviewers to cut corners and lose mental comprehension of the codebase. Testing Inflation and the Conjunction of Booleans (21:35) Downstream infrastructure limits intensify across testing and version control. Because codebase dependency graphs scale quadratically rather than linearly, a 10x expansion in code can trigger a 100x to 1,000x surge in required test executions. Traditional version control systems, designed around cryptographic integrity rather than ingestion throughput, struggle under high-frequency agent commits. Simultaneously, demanding that every single test passes—what Bender terms the "conjunction of Booleans"—becomes mathematically impossible across millions of runs due to baseline infrastructure flakiness. Software organizations must inevitably transition toward statistical, risk-weighted testing models. Operational Hazards: APIs, Cadence, and Mentorship (26:59) Unmanaged agent workflows introduce novel operational vulnerabilities. Because autonomous agents systematically discover internal endpoints, internal enterprise APIs require the strict perimeter hardening typically reserved for public interfaces. Furthermore, release cycles face the race condition where deploying faster than mean time to detect regressions corrupts rollback states with interleaved changes. Organizationally, "everyone is a builder" dynamic fractures shared infrastructure with bespoke, siloed apps, while entry-level developers orchestrating swarms of agents wield massive blast radius without having acquired the years of pattern recognition necessary to evaluate systemic failures. AI as an Amplifier and Reclaiming Intellectual Control (32:05) Citing DORA research, Bender observes that generative AI acts as an amplifier rather than a remedy. Applying AI to teams with disciplined code health and release hygiene increases delivery, while applying it to fragmented teams merely accelerates debt and confusion. To prepare for 2030, engineering organizations must establish strict isolation boundaries between prototype and production systems, and deploy robust abstractions that constrain agent decision spaces. Ultimately, Bender argues that AI's greatest opportunity lies not in generating more code, but in synthesizing code, configs, and telemetry into interactive models that allow humans to reclaim intellectual control over systems too vast for any single mind. Bender urges developers to shift their mindset from inspecting individual trees to managing entire socio-technical forests. Because technical systems are tightly coupled, localized actions by practitioners exert outsized leverage in determining whether generative tools degrade codebases into unmaintainable sprawl or empower sustainable engineering.

Source quotes

[3:29] Adam Bender: Your ecosystem builds what your organization incentivizes; your engineering culture creates the environment around your developer ecosystem. [8:59] Adam Bender: 10 lines of code in the right place can patch 10 billion lines of application and system software. [17:35] Adam Bender: Agents are good at writing code, but they're not always thinking long term the same way you and I need to. [24:09] Adam Bender: It might not be possible to ship software where every Boolean has to be true. [11:57] Adam Bender: The trade-offs you're going to make are really important to pay attention to, because when you look at the trade-offs being made, you can begin to understand the values of the organization. [35:05] Adam Bender: Intellectual control, by the way, is just a fancy way of saying, can humans reason about this thing in front of them?

Original transcript

[0:00] [MUSIC PLAYING] [0:05] ADAM BENDER: Hey, everybody. [0:07] How you doing? [0:07] [CHEERS] [0:09] Hey, that's pretty good! [0:11] That's pretty good. [0:12] 3:00 PM on a Wednesday, right? [0:16] It's a Wednesday-- not so bad. [0:19] Welcome to Software Engineering at the Tipping Point. [0:22] My name is Adam Bender. [0:24] And today I'm going to talk to you about something [0:26] called software ecology, a term you might not have heard before. [0:29] I want to talk about it because it will tell us something [0:32] about the impact of AI on our developer ecosystems, [0:35] the developer ecosystems you work in every day. [0:37] Now I don't know if you guys have noticed this. [0:39] But things are getting pretty weird out there, right? [0:42] Your job in 2026 does not look like what [0:45] you thought it would in 2020. [0:47] I assure you that. [0:48] If you tried to explain to 2020 me what this was going to be, [0:51] I would not have believed you. [0:53] It can be a bit overwhelming to try and figure out [0:55] where all of this change is taking us, right? [0:59] And while I can't predict the future, [1:01] I think that if we study our software ecosystems as they [1:04] are today, some of the answers we're [1:06] looking for are a lot closer than we think. [1:08] I think that software ecology, this idea, [1:10] it gives us the perfect lens for framing this particular moment [1:14] in our industry. [1:15] Now I can hear you asking, what is software ecology? [1:18] And did he just make this up to get on stage? [1:21] I did not. [1:22] It is a real term. [1:23] But before I define it, I want to set some context for you. [1:26] So we're going to go a little deep-dive on systems thinking. [1:28] I hope you're OK with that. [1:30] Hang with me. [1:30] I promise you, it will all make sense when we get there. [1:34] So let's start with the concept of a system-- a system. [1:38] It's a group of interrelated elements [1:39] that act according to a set of rules to form a unified whole. [1:43] That sounds pretty fancy. [1:44] But you know systems. [1:45] They look like this. [1:46] This is a system you're probably pretty grateful for today. [1:49] This is what air conditioning is, right? [1:50] So you have a thermostat that knows what temperature to be. [1:52] You have an HVAC that's going to jack the temperature up or down. [1:55] And you have a room. [1:56] And when the temperature is right, the signal stops. [1:59] That's a system. [2:01] If you're a software engineer, you're [2:02] probably used to thinking about systems all the time. [2:05] You design them. [2:05] You build them. [2:06] You operate them. [2:07] But one thing you've probably learned [2:08] when working with systems is that everything [2:11] is connected, everything. [2:13] That's a theme you're going to hear from me a couple times [2:15] today. [2:17] Now let's move on to an ecosystem, which [2:19] is a particular kind of system. [2:22] This is a long one. [2:22] So bear with me. [2:24] An ecosystem is a dynamic network of interdependent actors [2:27] that co-evolve with their environment, characterized [2:29] by emergent behavior and decentralized agency. [2:33] Ecosystems are complex. [2:36] They're built from complex components. [2:38] The components themselves are deeply connected. [2:40] They have agency. [2:41] They can make decisions. [2:42] They can do things. [2:43] And critically for us, the environment [2:46] is a part of that system. [2:48] The environment is a part of the system. [2:50] You can't separate the two. [2:53] So ecosystems are also a kind of complex adaptive system. [2:56] A Complex Adaptive System, or CAS, they're [2:59] characterized by their ability to grow and change and evolve [3:02] over time. [3:03] All the cool systems are complex adaptive systems. [3:05] Now, complex adaptive systems, they [3:08] possess this emergence quality as well. [3:10] An emergent property is something [3:12] that you can't see by looking at any individual piece [3:14] of the system. [3:15] You can only see it when the system is all put together. [3:18] And then you see behavior emerge out of it. [3:20] And it's that constant change, that learning, [3:22] plus the emergence that make it really hard to figure out what's [3:25] going on in an ecosystem. [3:29] Now when you think of ecosystems, [3:30] or at least when you thought of them before you walked in here, [3:32] this is probably what you had in mind. [3:34] And frankly, I'd like to be here right now, right? [3:36] Looks kind of idyllic. [3:38] But your internal developer environment, [3:40] it is also a kind of ecosystem. [3:42] You have all your tools and services. [3:44] You have complex actors. [3:45] You have people with opinions and things [3:46] they want to get done. [3:47] You have business constraints. [3:49] This is a system, too. [3:50] And in fact, it's a particular kind of system. [3:53] It's a socio-technical system. [3:55] A socio-technical system is just a fancy way [3:58] to say a system made of people and technology. [4:01] Now socio-technical systems are incredibly complicated. [4:05] They're complicated because you start with all that technology. [4:08] And then you mix in the people. [4:10] There's a pretty good chance though that you've [4:12] encountered some wisdom about socio-technical systems [4:15] without even realizing it. [4:17] Have any of you ever heard of Conway's law? [4:19] Yes, of course. [4:20] Everyone has heard of Conway's law. [4:22] But briefly, Conway's law goes like this. [4:24] Organizations build technologies that [4:26] mirror their internal communication structures. [4:29] Or informally, if you have a four-team group [4:31] working on a compiler, you're going [4:33] to get a four-pass compiler. [4:34] That's just how it works. [4:36] Now at its core, Conway's law is an observation [4:38] that the way we build technology is [4:40] inseparable from the structure of the organizations that [4:43] build it. [4:43] The organizations shape what gets built. Now of course, [4:47] it's not just the organizational structure [4:49] that impacts our developer ecosystems. [4:52] The values and culture of an organization [4:54] can have just as profound an impact. [4:57] Your ecosystem builds what your organization incentivizes [5:01] your engineering culture creates the environment [5:03] around your developer ecosystem. [5:06] See, the thing is, once you learn [5:08] about socio-technical systems, you [5:09] see them everywhere in software development, [5:12] from your architectures, to your postmortem culture, [5:14] to code review, to security policy. [5:16] They're everywhere. [5:17] The things we build and the way we choose to build them [5:20] are a reflection of what we value. [5:22] If we're thoughtful, we can use that knowledge [5:24] to amplify our values and put them into the things [5:26] we build, boosting the kinds of outcomes that we want. [5:31] So now I think I can properly define [5:33] for you, software ecology. [5:35] Software ecology is the holistic study [5:38] of the socio-technical ecosystems [5:40] that produce software. [5:42] All right. [5:43] Now we're all caught up. [5:45] It's OK if all that felt a little abstract, by the way, [5:48] because now we're going to look at a real example. [5:50] We're going to talk about Google's developer ecosystem. [5:53] Google has a very large, and I would argue somewhat [5:56] complicated, developer ecosystem, [5:58] because over the last 25 years, we [6:00] have evolved truly remarkable capabilities [6:03] and, yes, a little complexity. [6:05] Now as an upfront disclaimer, I'm talking about Google, [6:08] partly because I work there. [6:09] But it is the developer ecosystem I understand the best. [6:11] My intent here is not to tell you, [6:13] you got to go do what Google did. [6:14] That's not going to be good for you. [6:16] You're a different company. [6:18] You're in a different place. [6:19] You have a different set of trade-offs you're worried about. [6:22] Now like any engineering organization, [6:24] Google has made a lot of choices. [6:25] They were very specific to the needs we had at the time [6:28] we were building our ecosystem. [6:30] Your situation is different. [6:32] So a few years ago, we wrote a book. [6:34] Maybe some of you have seen this book before? [6:36] Internally, we call it the Flamingo Book. [6:38] We wrote this book to give people an understanding of how [6:41] Google actually worked inside. [6:42] And we spent half this book talking [6:44] about things like version control and testing. [6:46] But the entire first half of this book [6:47] was spent on engineering culture. [6:49] And we used to get a lot of questions about that. [6:51] Why so much on engineering culture? [6:52] Well, the reality is, if you don't understand the culture [6:54] that Google has, you can't appreciate [6:57] why we have the technical choices that we've made. [6:59] These things are interlinked. [7:01] Now in case you didn't read the book, [7:03] I'm going to give you a brief tour. [7:04] Don't worry. [7:05] You don't need to read all this. [7:06] Yes, take pictures. [7:06] That'll be fine. [7:08] There's a few things about Google [7:09] that make it somewhat unique. [7:10] So for example, we're deeply engineering-led. [7:12] Engineers are always in the room when important decisions [7:15] are being made. [7:15] We're big on transparency. [7:17] We try to make all the docs and code that we can [7:19] available as often as possible. [7:21] We encourage people to be helpful. [7:23] In fact, if you talk to anyone who's ever left Google, [7:25] the helpfulness of their colleagues [7:26] will be one of the most important things they cite. [7:29] We treat code review as an opportunity for mentorship [7:31] and not test grading. [7:32] We're big on standardization, real big on it. [7:35] We believe in continuous improvement. [7:37] We're big into blameless postmortems. [7:40] We're big on the idea that sustainability [7:42] is better than heroics and that automation is better than toil. [7:45] Now we don't always achieve all of these ideals. [7:47] But this is kind of what we're aiming for culturally. [7:50] And on the technical side, we have our monolithic repository [7:53] you've probably read about. [7:54] I'll tell you more about that in a second. [7:56] We have trunk-based development, where every change [7:58] lands at head every time. [8:01] When you build a binary at Google, [8:02] almost every line of code is built from source. [8:04] That's pretty wild, right? [8:06] We have a universal build tool chain. [8:07] Everybody uses it. [8:08] We have a global test automation platform. [8:10] One place runs all the tests, billions of tests a day. [8:13] We have a global signal for the last green. [8:15] I can tell you the state of any build, [8:17] looking at one simple internal website. [8:19] We have a uniform compute environment. [8:21] So it works on my machine isn't possible, mostly. [8:24] We have opinionated developer frameworks and a small set [8:27] of core languages. [8:28] And it's this mixture of culture and technology [8:31] that give rise to what Google is. [8:33] You can't understand one half without the other. [8:36] Now if I had to pick one principle, [8:39] one principle that seems to have guided us implicitly, [8:41] if not explicitly at times, it's this thing called shared fate. [8:45] Now, shared fate is a term that describes [8:46] the degree to which an ecosystem and its components [8:50] are tightly linked to each other. [8:51] In a high shared fate ecosystem, one component [8:54] can affect everything else, right? [8:57] Now in a developer ecosystem, shared fate [8:59] is as much a technical choice as a social one. [9:02] You can't just get shared fate by making everyone [9:05] use the same technology. [9:06] You also have to develop social contracts [9:07] for how you're going to manage that technology. [9:09] Now at Google, our shared fate starts [9:12] with our monolithic repository. [9:15] Every line of code at Google, with a couple notable exceptions [9:18] like Android and Chrome, is in one shared repository, [9:21] everything. [9:22] Everything is committed to trunk. [9:23] There are no branches. [9:24] There are no versions-- everything in one place. [9:27] This kind of shared fate allows us [9:29] to apply a security patch in one file [9:31] and know that, within a week, every application in the company [9:34] will have been patched. [9:35] That's like a superpower, right? [9:37] 10 lines of code in the right place [9:40] can patch 10 billion lines of application and system software. [9:45] That's pretty impressive, right? [9:47] Now, shared fate isn't always a good thing. [9:51] Shared fate is a choice. [9:52] There are places where shared fate might make less sense. [9:55] For example, in our production environment, [9:57] we don't want one service to take down [9:59] all the other services or one cluster [10:01] to infect an entire region. [10:03] So we have worked really hard. [10:04] Google in particular has worked really [10:06] hard to make sure we don't have the dangerous kinds of shared [10:08] fate that cause things like cascading failures. [10:11] Again, the point is, shared fate is a trade-off. [10:13] You have to figure out the right place [10:15] to put it, and then make sure that it works well for you. [10:18] Now one of the most interesting emergent properties [10:20] of our shared fate environment is this notion [10:23] of large scale changes. [10:25] Now long before AI, way before AI, [10:29] Google's internal tools have made [10:30] it possible for a single developer [10:32] to change literally millions of lines of code-- [10:35] millions of lines of code, code they will never look at. [10:37] They will never see again. [10:39] They might know nothing about it. [10:41] We've built tools that make that automatically possible, today. [10:44] And we've been doing it that way for at least the last 15 years. [10:47] This kind of capability has let us to evolve our monorepo [10:50] over time. [10:50] We can update languages and frameworks. [10:53] It's really what keeps our internal environment [10:55] from becoming stagnant. [10:56] It's no exaggeration to say that, without it, we wouldn't be [10:58] the Google that we are today. [11:00] And the folks who work on those tools would tell you. [11:03] It's an unsung hero's kind of job [11:04] to keep this company moving at the speed it needs to move. [11:09] The thing about large scale changes [11:11] is, you can't appreciate them unless you understand [11:13] the cultural components and the technical parts of our ecosystem [11:16] that make it possible. [11:17] For example, you need a widespread testing culture. [11:19] Everybody needs to be writing tests for me [11:20] to be able to do this. [11:21] We need to have a single platform [11:23] so I know where to look to get the results of those tests, [11:25] right? [11:25] It's good to have common build tools so we're all [11:27] building the same software. [11:28] I build it. [11:29] You build it. [11:29] We get the same outcome. [11:30] We need a standard set of libraries. [11:31] So as we're swapping things out, we're [11:33] not jumping around, trying to find [11:34] which version of this library is working for you and not me. [11:37] We need standardized code review. [11:38] We need transparency in the monorepo itself, [11:40] so I know which code needs to be changed. [11:43] LSCs are truly the ultimate manifestation of this automation [11:46] over toil ethos at Google. [11:48] And it's only possible because of the entire ecosystem. [11:51] You can't point at one part of our developer environment [11:53] and say, that's why LSCs happen. [11:55] It's everything linked together. [11:57] Now, every developer ecosystem, yours, [12:00] anyone you've ever worked in, they [12:02] have these emergent properties. [12:03] They're usually the things that feel [12:05] somewhat unique to the place that you work. [12:07] And that's because they're usually [12:08] the result of the constellation of choices [12:10] you have made to shape how you want to work. [12:13] So every ecosystem has something like this. [12:15] Google has large scale changes. [12:16] You have something else. [12:18] Google's developer ecosystem, embedded [12:20] in our specific engineering culture, [12:22] has produced a unique set of trade-offs. [12:25] They serve our technical and business goals. [12:27] However, Google's ecosystem, like every ecosystem, [12:30] cannot excel at all tasks. [12:32] We've chosen to optimize for extreme scale, security, [12:36] performance, right? [12:36] And we'll do that typically even if it [12:38] comes at the expense of developer productivity [12:40] sometimes. [12:41] That's a trade-off we're willing to make in our ecosystem. [12:44] The developer ecosystem of other places, [12:46] like, say, a five-person startup is going to look different. [12:48] And that's OK. [12:49] In a five-person startup, velocity and agility [12:51] are the most important things you can possibly have. [12:54] Somewhere in between a five-person startup and Google [12:57] is where you are, right? [12:58] Most of you are inhabiting an ecosystem that's somewhere [13:00] between five people and 200,000. [13:03] The trade-offs you're going to make [13:04] are really important to pay attention to, [13:06] because when you look at the trade-offs being made, [13:07] you can begin to understand the values of the organization. [13:10] What does it really care about? [13:12] Not what does it say it cares about, [13:13] but what does your organization actually care about? [13:16] And when you understand those values, [13:18] you can begin to shape the transformation [13:20] as it begins to unfold. [13:21] We're all experiencing a lot of transformation right now. [13:23] So it would be good to understand where we're going. [13:26] I hope by now, the concept of a software ecosystem [13:29] is a bit more clear. [13:30] And I think it's time we talk about the token-eating elephant [13:33] in the room. [13:34] What does an AI-first developer ecosystem actually look like? [13:38] Now it would be nice to build one of these out from scratch, [13:42] a greenfield ecosystem. [13:43] But I would bet none of you have that luxury, right? [13:46] You all have to continue shipping software, [13:47] doing what it is you're doing today, [13:49] while you're replacing literally every part of it. [13:51] No big deal, right? [13:53] Your company is depending on you to continue delivering value [13:56] and make sure that nothing breaks. [13:58] So to make sure nothing breaks, let me ask you a question. [14:01] How well do you understand your developer ecosystem today? [14:04] Can you map it all out? [14:07] Do you know where all the pieces are, [14:09] not just the technical ones, but the social ones? [14:10] Can you enumerate what your ecosystem is actually [14:12] built from? [14:13] How well do others in your organization understand it? [14:16] What are its strengths or its weaknesses? [14:18] Where are your bottlenecks? [14:19] Where are you constrained or where are you free? [14:22] What optionality do you have? [14:23] What kind of emergent properties have you [14:25] seen in your own ecosystems? [14:26] And perhaps most importantly, if your ecosystem suddenly had [14:29] to grow by, I don't know, 10 to 15x in the next 18 months, [14:33] do you know what would break first? [14:36] See, the thing about that last question [14:38] is we're all going to have to answer it real quick, [14:41] because every developer ecosystem on Earth [14:43] is going through a radical transformation. [14:46] Maybe it hasn't gotten to everywhere you are yet. [14:48] But it's coming. [14:51] Every single developer ecosystem is going to have to wrestle with [14:53] this idea of this 10x moment. [14:56] I wish I could tell you there was a way out of this. [14:58] But it's coming. [14:59] These are incredible times. [15:01] But they are also somewhat confusing. [15:04] All the trade-offs we have deliberately [15:05] evolved over the last 25 years are going to get re-balanced. [15:08] You've heard that from probably every speaker here [15:10] in some form or another. [15:11] We don't know yet what the future is going to be. [15:13] We're trying to figure it out. [15:14] Some folks are predicting productivity that looks like [15:17] 10x, 100x. [15:18] We're measuring things in orders of magnitude. [15:21] That's a lot. [15:23] Suddenly, the question of 10x growth is not just a thought [15:26] exercise. [15:27] It's like a code red moment for you and your company. [15:29] You're going to have to figure this out, if not [15:31] today, certainly in the next 12 months. [15:34] Now before I go much farther, I really [15:36] want to stress that I understand, [15:37] there's a big difference between generating code [15:40] 10 times faster and engineering 10 times faster. [15:43] These are different things. [15:44] And in fact, at Google, we often say [15:46] that engineering is programming integrated over time. [15:49] But the thing is, we're speeding up programming a lot. [15:52] We're making the code machine go fast. [15:54] So we're going to have to figure out how we engineer around [15:57] that code machine in order to deliver [15:58] real results to our customers. [16:01] No one knows yet how far we can push this productivity growth. [16:04] I really don't know. [16:05] We could stop next week. [16:06] I don't think so. [16:07] But one thing's for sure. [16:08] We're going up from here. [16:11] The problem is, I think we have a lot of work to do, [16:13] because I would bet very good money that what we're doing [16:15] today doesn't work at 10x. [16:17] I would bet, the way you're building software, [16:19] the way I'm shipping software, doesn't work at 10 or 100x [16:22] velocity. [16:22] Something's going to have to change. [16:25] Well, let's start by looking at a standard developer ecosystem. [16:28] It's simplified. [16:29] I know. [16:29] Hopefully you'll recognize some of these terms up here. [16:31] But let me put them in a form you're more used to seeing [16:34] them, a complex graph, right? [16:35] In a world with 10x more productivity, [16:37] or 10x more activity, rather, what has to change? [16:40] Well, let's start with the nodes related to getting code [16:42] into the code base. [16:43] Now, notably, I've excluded testing and version control. [16:46] We'll get to those in a second. [16:48] What happens if the green nodes suddenly [16:50] have to do 10 times more stuff? [16:52] Well, let's start with writing source code. [16:55] If everyone gets a lot faster at writing code, [16:57] there's probably going to be a lot more of it, right? [16:59] That's not good. [17:00] Now seems a very good time to remind you of an old Jeff Atwood [17:03] quote. [17:04] Software is a liability. [17:07] So right off the bat, 10x more code, 10x more liability. [17:11] We're not into a good place. [17:13] By the way, you've probably noticed [17:14] that you can't just hand everyone a bunch of tokens [17:16] and say, good luck. [17:17] So I hope you're investing in retraining. [17:19] You are investing in retraining, right? [17:22] Do you know where all your engineering practices [17:24] are documented? [17:24] Would you know how to evolve them if you had to? [17:27] OK. [17:27] Well, something to think about when you get home. [17:29] Let's move on to the build system really fast. [17:31] At a minimum, more code is going to mean more compile time. [17:35] Bigger system, more compile time, just what we needed. [17:38] I'm sure no one at your company has ever [17:39] complained about slow compiles. [17:41] Well, guess what? [17:42] They're going to get slower. [17:43] And if agents are driving a lot of work, [17:44] that means more compiles-- so not just bigger, but more. [17:47] Compilation isn't free, in time or compute. [17:50] And it's possible you have never noticed how much time you [17:53] spend on compilation. [17:54] But I can assure you, 10 times larger, [17:56] you're going to notice something. [17:58] What about the design of all that code? [18:00] Do you have the right agentic skills to encourage decoupling? [18:03] What about the right server frameworks [18:04] to ensure that you can compose capabilities quickly and safely? [18:08] Come to think of it, do you know how many ways [18:10] web applications are served in your company today? [18:12] Do you know how many different server frameworks are actually [18:15] running? [18:16] I don't, actually. [18:18] How are you going to manage component reuse if agents [18:20] are writing all of that code? [18:22] Maybe you're betting it won't matter. [18:24] Don't be surprised though if agents [18:25] write code that is easy to write and hard for you to maintain. [18:29] That seems to be the benchmark right now. [18:31] Agents are good at writing code. [18:32] But they're not always thinking long term [18:34] the same way you and I need to. [18:36] That code, I'm sure, won't be well-factored. [18:38] That's OK. [18:38] We'll figure that part out. [18:39] But the truth of it is, agents are doing a lot of work for us [18:45] now. [18:45] And we're going to have to figure out [18:47] how we apply that most effectively, every single day. [18:51] At some point, all that agentic work [18:53] could make your binary so big, you can't compile them anymore. [18:57] Or maybe they get so big, you can't ship them on phones [19:00] anymore. [19:01] Have you ever asked the question, [19:02] what is the largest binary you can compile? [19:06] I actually don't know what the answer is. [19:07] But I know we're bumping into limits at Google. [19:09] We're getting our binary so big in some places, [19:12] we can't compile them anymore. [19:13] We'll figure it out. [19:14] I'm sure of that. [19:15] But the truth is, big has lots of consequences. [19:18] Scale has impacts everywhere. [19:21] Now perhaps you're more of a microservices shop. [19:23] And you're looking at me, going, why would I ever build [19:25] a service that big? [19:26] All my services are tiny. [19:28] That's cool for you, except now I have a question. [19:30] What's going to happen with 10x more network traffic, [19:33] 10x more services, 10x more chatter, [19:35] 10x more network traffic? [19:36] Are you ready for that? [19:37] No one gets out of this unscathed. [19:40] Scale has effects everywhere. [19:43] Now let's say you can't reliably compile all this code. [19:45] I'm sure you can't, right? [19:46] What happens to your code review process? [19:48] Everyone is worried about code review right now. [19:50] And I think that's for good reason. [19:51] We're putting a lot of pressure on this very human process. [19:56] And in many cases, it is becoming a bottleneck. [19:58] And one thing I know about people, [19:59] they do not like to be bottlenecks. [20:02] They act funny when you put pressure on them. [20:04] With 10x more code, you're going to get one of two things, [20:07] 10x larger changes or 10x more of them. [20:09] So what does that mean for your code reviewers? [20:11] Well, I'd be willing to bet most of your tech leads cannot [20:13] sustain the review velocity necessary to see, I don't know, [20:16] even five of these 10x developers through a day. [20:19] That's a lot of work. [20:21] So what they're going to do in order to not become [20:23] a bottleneck is they're going to start rearranging their process. [20:26] They're going to start cutting corners [20:27] to make sure they don't block anyone, [20:29] because no one wants to be a blocker. [20:31] Now you may be able to solve part of this with AI. [20:33] I'll give you that. [20:34] You may be able to deploy AI to make your review process better. [20:37] OK. [20:38] But that only solves part of your problem, [20:40] because if the people on your team aren't writing code, [20:43] then the only time they're encountering [20:44] it is during review. [20:45] But they're not paying as much attention during review. [20:47] That's what we just said. [20:48] So who's paying attention to the code base as it evolves? [20:51] Well, no one. [20:52] Pretty soon, your code base is going [20:54] to be a mess that no one can understand. [20:57] Now in addition to all that source code, [20:59] we have to think about token management [21:01] because tokens are expensive, as some of you probably know. [21:04] At scale, tokens are a real cost we have to factor. [21:07] What happens if everyone in your company [21:09] starts using 10 times more tokens or 100 times more tokens? [21:11] Or what if you accidentally spend your monthly budget [21:14] in a day, a thing that has happened to a friend of mine. [21:17] If you had to prioritize where you're going to put that spend, [21:19] do you know where you'd put it? [21:21] Do you even have the visibility to know where [21:23] the tokens are going right now? [21:25] See, even in just the first few nodes [21:27] of this system, this simple system, [21:28] we're already finding problems. [21:30] And it is very clear that there's [21:32] going to be some challenging second order impacts. [21:34] Now let's move on to testing and version control. [21:36] These are a little bit special. [21:38] Have you ever looked at how much compute your testing [21:40] infrastructure takes? [21:41] I do not know about you. [21:42] But at Google, I never have fast enough tests. [21:45] I've never said, boy, my tests are going [21:46] faster than I needed to today. [21:48] I don't have enough capacity as it is. [21:51] Every change that lands in version control [21:53] has to be tested, though. [21:54] But also, agents love running tests [21:56] because it tells them whether or not they're doing good work. [21:58] So again, the agents are doing additional work. [22:00] And I have more work to do. [22:02] So with 10 times more commits and agents doing all that work, [22:05] now how much test compute are you using? [22:08] Actually, it turns out it could be worse than that, [22:10] because what we've seen at Google [22:11] is that as your code base grows, your dependency graph grows [22:15] quadratically, not linearly, with the size of your code base. [22:19] So if your code base is 10 times larger [22:21] and you're trying to test all the dependencies so that you're [22:24] sure nothing will break, you may have [22:25] upwards of 100 times as many tests running. [22:28] Maybe it's 1,000 times as many tests running. [22:30] That's going to be a really interesting challenge. [22:32] And it's going to be a line item in your budget at some point. [22:36] That's something you should be thinking about. [22:39] So now you're not just running tests more often. [22:42] They may be 100 times bigger. [22:44] And quite frankly, if they're not [22:45] going to get that big, if you're not worried about how much test [22:48] compute you're spending, I'm more worried, [22:50] because that means you probably don't have [22:51] enough tests to begin with. [22:52] And those agents are YOLO-ing all over your code base [22:54] with no way to know what is working, all right? [22:58] Now let's assume you figure that out. [23:00] You've solved compile. [23:00] You've solved testing. [23:01] Let's talk about your version control system. [23:03] Most popular version control systems [23:05] are not optimized for performance, not at all. [23:08] They're optimized for consistency, ordering. [23:12] That's their job. [23:13] Their job is to keep a complete record, not to go real fast. [23:15] What's the performance of your version control system? [23:17] How many commits can it take a minute? [23:20] I assure you, it is less than you think. [23:22] It's not going to scale to 10x the velocity that you need it [23:26] to. [23:27] When was the last time you even thought [23:29] about the performance of your version control system, ever? [23:33] Not unless you work on Git, right? [23:34] Honestly, if we're talking about version control performance, [23:37] something has gone horribly wrong. [23:39] We are in the bowels of the developer experience [23:41] here, the bowels. [23:43] But that's what happens when you see systemic change. [23:46] Systemic change finds every corner of your system [23:49] and says, hey, you paying attention? [23:50] Because here's something that you weren't expecting. [23:53] And by the way, for those of you who [23:54] think you're going to solve this version control [23:55] problem with a lot of little repos, I got some news for you. [23:58] Talk to anyone who's run that strategy who has hundreds [24:00] or thousands of little repos. [24:02] And I can assure you, it's just an entirely new set [24:04] of challenges, none of which AI is going to necessarily make [24:06] easier for you. [24:09] So far, we've hit problems in every node we've looked at. [24:12] And believe it or not, we've only [24:13] looked at the relatively easy to find capacity nodes. [24:15] These are all things you could just find. [24:17] You just take a number, multiply it by 10 and ask, [24:20] will that go good or bad? [24:21] There's a lot of other unexpected challenges. [24:22] So we're going to go through a really quick list of some things [24:25] I think you want to be worried about. [24:27] So first, validation beyond just your compute. [24:31] The validation strategy you use today [24:33] is probably something like a lot of unit tests and maybe [24:35] some integration tests. [24:36] But with 10x more code and 10x more services, [24:38] integration tests are going to become the most important part [24:41] of your quality strategy. [24:42] How many of you are happy with your integration testing setup [24:45] today? [24:46] I will note for the live stream, there is not a single hand up. [24:49] OK, good. [24:49] That's what I thought. [24:50] I am also not happy. [24:52] Integration testing is really hard. [24:53] And I do not have the tools to do it [24:55] the way I would like to right now. [24:57] Then you have this problem that I [24:58] refer to as the conjunction of Booleans. [25:00] In order to ship software today, you [25:01] request that every test pass. [25:03] All the Booleans turn green. [25:05] Everything is good before you ship. [25:06] That's a reasonable thing to do. [25:08] What happens when you have a million tests? [25:09] And the actual reliability of the underlying test [25:11] infrastructure to run a million tests is in question. [25:14] It might not be possible to ship software where [25:17] every Boolean has to be true. [25:18] So now you're going to need a new strategy, probably [25:20] something statistical to figure out, [25:22] what are the right tests to run? [25:23] Because I can't run everything. [25:26] OK. [25:26] What about super, extra large changes? [25:28] It's really exciting that we can refactor and change languages [25:30] and frameworks, everywhere. [25:31] Everyone can do it. [25:32] Do you have the workflows or the social contracts [25:34] to enable people to manage merge conflicts [25:36] that are measured in the tens of thousands [25:38] of lines, hundreds of thousands of lines, millions of lines? [25:41] Probably not. [25:42] So we're going to need to figure out, [25:44] how do we build the workflows that support very large change [25:47] sets moving past each other? [25:48] If everyone at the company can do it, [25:50] we're going to need a new strategy. [25:52] And by the way, have you ever seen an agentic edit war [25:55] where one edit, an agent makes a change. [25:57] And then another agent comes in and says, [25:59] no, I don't like that change. [25:59] Let's do a different change. [26:01] Now, it's funny to watch until you [26:02] realize you're paying for the tokens on both sides of that, [26:05] right? [26:07] Let's move on to release. [26:08] How many times do you release to your customers today, daily? [26:11] If you're doing daily, you're doing pretty good. [26:13] If you're not, here's a problem for you. [26:15] You're going to get 10x more software. [26:17] And that software has to land somewhere. [26:19] And if you're not releasing daily, [26:21] my guess is that each change is now going to get a lot bigger. [26:24] And if there's one thing my SRE friends will tell me, [26:26] it is that very large changes are very scary. [26:29] Let's not do that. [26:30] But the code has to go somewhere. [26:31] It needs to get deployed to be valuable. [26:33] So one thing you're probably going to try to do [26:35] is release more frequently. [26:37] And that's good. [26:37] Our friends at DORA would be proud. [26:39] They would say, yes, please release more. [26:40] But at some point, you're going to release diminishing returns. [26:43] Releasing every second is probably not [26:45] going to provide a lot of value to you. [26:47] So somewhere between releasing every second and I'm [26:49] not quite to releasing a day is the right balance. [26:51] But still, the code will grow. [26:53] And we're going to need to figure out, [26:54] where do we put that code so that we don't create more risk? [26:59] How about your internal APIs? [27:01] We've been talking about building software. [27:03] But what about the internal developer environment [27:05] with all the APIs and data? [27:06] What I've been telling my friends that I work with is, [27:08] all of your APIs suddenly just became public. [27:11] They need the same kind of hardening [27:13] that you would put on anything that you're going to send out [27:15] to the public internet. [27:16] Why? [27:16] Because agents aren't going to negotiate with you. [27:19] They're going to find an API. [27:20] They're going to start calling it. [27:21] And if they can get access to your data, [27:22] they're going to do it. [27:23] I guarantee it. [27:24] If an agent can access a data set, it's available to them. [27:27] So if you haven't put the same thought into your internal data [27:29] sets and your internal APIs, you're [27:31] going to run into some very interesting challenges, [27:33] because agents are going to find things [27:34] you probably didn't want them to. [27:36] Well, how about Jevon's paradox? [27:37] This is a word we all learned in the last probably 12 months. [27:40] No one knew what this was or even how to pronounce it. [27:42] But now we all know about Jevon. [27:43] Jevon says, the cheaper and more efficient a resource gets, [27:46] the more we use it. [27:47] And, boy, do you see that with tokens. [27:49] We are putting them everywhere. [27:50] And it's changing how we work and how [27:52] we think about how we work. [27:53] We're now optimizing-- or not optimizing. [27:55] We are putting a cost on previously-hidden productivity [27:59] work that was invisible before. [28:00] So what is that going to do to the way we behave? [28:03] I don't know yet. [28:04] By the way, you need to be careful where [28:06] you put those token engines. [28:08] If you put load-bearing token engines in place, [28:11] weird things can happen. [28:12] For example, what if your rollback [28:13] process depends on an agent to have enough capacity? [28:16] If someone ran that agent out down the end of its token budget [28:19] and now you can't roll back, that's probably a bad thing. [28:22] And speaking of rollbacks, do you guys know why rollbacks [28:25] work today, basically? [28:26] It's because you release software [28:28] slightly slower than it takes you to detect [28:30] a problem in production. [28:32] If you can release software really, really fast, faster [28:35] than you can detect anything is wrong, [28:37] what does that mean for your rollback posture? [28:39] Every rollback will now have to contend [28:41] with multiple conflicting changes landing on top of it. [28:43] So it's not just enough to release faster. [28:45] We have to consider the whole system, the rollback as well. [28:47] That's a really important safety valve. [28:49] How about the idea that everyone's a builder? [28:51] This has been a big conference for celebrating the idea [28:53] that everyone's a builder. [28:54] And I think it's cool. [28:55] Democratizing engineering is cool, [28:57] until you realize you have democratized engineering. [29:00] You know that tool that you don't like, [29:02] that you wish you could replace at your company? [29:05] I don't care what it is. [29:06] And I won't name names up here. [29:07] But I'm sure there's a tool you just wish I could vibe code [29:09] up a replacement for. [29:10] OK. [29:11] Multiply that by everyone at your company for every tool [29:13] they use. [29:14] What happens to the social fabric of your company [29:16] when everyone is using completely different tools? [29:18] Now if you're lucky, you have a common data substrate. [29:20] That's a good thing. [29:21] Then all the data is going into the same place. [29:23] But what if you don't? [29:24] Everyone's a builder is cool, until you [29:26] have to maintain all the stuff that everyone built. [29:29] And let's spare a thought for the technical leadership speed [29:31] run we're going to put all our junior developers through. [29:34] The reason that it takes so long to become a lead [29:36] is because you have to build intuition and judgment [29:39] and expertise to help you make calls, [29:41] because when you're leading a team, [29:43] there's a blast radius that is much larger than when [29:45] you're just doing it yourself. [29:46] When a new grad steps into an environment where [29:48] they have 50 agents at their disposal, [29:50] but none of the intuition and none of the judgment, [29:52] what's going to go wrong? [29:54] How do I teach 10 years of experience in six months? [29:57] I don't know yet. [29:59] And this last one you've heard a lot about, especially [30:01] in the last talk if you were here. [30:03] Human attention is the most precious resource we have. [30:06] And right now, there's a lot of noise. [30:07] There's so many agents, so many things demanding our attention. [30:09] We're going to have to figure out how to manage this, [30:11] because we don't know how to do it really well right now. [30:13] We've benefited from the fact that we couldn't [30:14] make more trouble for ourselves than we could pay attention to. [30:17] And now that is not the case. [30:20] All right. [30:20] So that seems like a lot. [30:21] That's because, in a system, everything is connected. [30:24] All the challenges I just mentioned, by the way, [30:26] you can't resolve any of these by just looking [30:28] at a single node in the system. [30:30] You have to look at the whole system. [30:32] In order to adapt to agentic development, [30:34] I think we're going to all have to start learning to think [30:37] in systems all the time. [30:39] So I'm not going to go through all of these. [30:41] Take a screenshot of it if you want. [30:43] But when you're thinking about systems, [30:44] these are the things you should be worried about, things getting [30:47] bigger, the effects over time. [30:49] Which direction does causality move? [30:51] Which nodes are talking to all of their neighbors? [30:53] What does emergence look like? [30:55] What are the things that are coming out of nowhere? [30:56] What about the incentives, both the social and the technical? [30:59] And that's right. [30:59] Technical systems can have incentives, too. [31:01] But be careful of the incentives in your ecosystem. [31:03] Capacity, I've said it a couple of times. [31:05] I'll hear it at least one more time today. [31:07] Feedback loops and bottlenecks, these [31:09] are the tools of systems analysis. [31:11] Now, it may seem complicated. [31:13] But you really only need two questions, why, and what if? [31:17] Why do we have so few integration tests? [31:19] What if we had more integration tests than unit tests? [31:22] Why do we use these specific programming languages? [31:25] What if AI writes all the code? [31:27] "Why" is the drill that you are going to use to bore [31:30] into the heart of your system to figure out how it works. [31:32] "What if" will challenge what you find. [31:35] And it will require you to flex your imagination a little bit. [31:38] All of you are probably very good at asking why. [31:40] I can see it in your faces. [31:41] You guys know how to ask why. [31:43] Why are we doing this? [31:44] Why are we doing that? [31:45] But, "what if", "what if" is more challenging. [31:48] "What if" can be scary, if we're asking you to abandon [31:50] the practices you thought were really well-designed [31:53] for the problems that you had. [31:54] "What if" can be scary. [31:55] What if we didn't test this way? [31:57] What if we didn't write tests at all? [31:59] Let's not get carried away, right? [32:01] But if you allow it to be, "what if" can also be pretty exciting. [32:05] Now while you're thinking about where these opportunities are, [32:08] I want to talk to you about a pattern that I've seen. [32:11] It's this pattern that AI acts as an amplifier. [32:13] As soon as I learned about this, I started seeing it everywhere. [32:16] Now I can't take credit for that idea. [32:17] That actually comes from my friends at DORA. [32:19] And their report last year on AI development, [32:21] they found this sort of relationship [32:25] among teams that have really figured stuff out. [32:27] They figured out how to make AI an amplifier. [32:30] AI can do more. [32:33] AI can get you more tests, more documentation, more code, [32:36] but also more confusion. [32:37] That's because amplification is a magnitude and not a direction. [32:40] AI doesn't care where all of that stuff goes. [32:43] It's just going to give you more of it. [32:45] What DORA really found was that teams that had good fundamentals [32:48] could apply that amplification in useful directions, which [32:51] begs the question, how are you feeling about your fundamentals? [32:54] How is the decision making culture in your company? [32:57] What could you do to improve it? [32:58] What about your technical strategies? [33:00] Is anyone looking at developer productivity? [33:03] How well do people in your organization collaborate today? [33:05] What's your security posture look like? [33:07] How's your code health, your release hygiene, [33:09] your reliability? [33:11] AI doesn't solve any of these problems for you, by default. [33:14] It can amplify the practices you have, if they're good. [33:17] But if they're not good, it's going to cause more trouble. [33:20] But even with solid fundamentals, [33:21] we're in for a real ride. [33:23] My guess is-- this is a guess. [33:25] You can come check me on it later. [33:26] In 2030, our developer ecosystems [33:29] today are going to feel like 2001 does to us now. [33:32] And I should point out that, in 2001, we were shipping software [33:35] on CD-ROMs, right? [33:36] That's how far away we might be in 2030. [33:39] Now as you continue to build your fundamentals, [33:41] let me give you some other things you can think about [33:43] along the way. [33:43] First and most importantly, you need [33:45] to know about infrastructure capacity. [33:47] You can't deploy the AI and you can't deploy the compute [33:49] if you don't know how much resource you have to spend. [33:51] You need a good way to keep track of this. [33:53] Next, you need validation, because you can't, or at least [33:55] you shouldn't ship software that you haven't validated. [33:57] But like I've said before, validation is going to change. [33:59] So you're going to need a validation strategy. [34:02] Now's the time to figure that out. [34:03] Beyond that, you need isolation, because you're [34:05] going to get a lot of code for a lot of different purposes [34:07] that, previously, we didn't use code for. [34:09] That's OK. [34:10] But you don't want that cool prototype code [34:12] to actually find its way into production. [34:13] So you need to worry about isolation. [34:15] You need to make sure the fun stuff doesn't [34:17] impact the money-making stuff. [34:18] And then, finally, you need to worry about abstraction. [34:21] We build abstractions to keep developers [34:23] from making bad choices. [34:24] That's why we build libraries and frameworks and whatever. [34:26] We wouldn't build a web server from scratch today. [34:28] There's frameworks-- because there's [34:29] a lot of ways to get things wrong. [34:31] Well, asking agents to make a lot of decisions [34:33] leads to the same consequences. [34:34] So we need good abstractions for the agents to hold on to. [34:37] Don't give them bad choices. [34:38] Now you're going to have to accept that engineering [34:41] practices are not sacrosanct. [34:42] Practices change. [34:43] It's the principles that matter. [34:44] And it's easier said than done. [34:46] I get that, especially when some of our principles [34:48] feel like practices. [34:49] They feel like they're all the same thing, like testing. [34:52] If you've never really thought about why your team tests [34:54] software the way it does or why your release process works [34:57] the way that it does, you're not going to be able to evolve it. [34:59] Understanding the principles is what's going to give you [35:01] the power and the confidence to change things as we move through [35:04] this 10x moment. [35:05] It is a fascinating time to be a software engineer. [35:07] I'm not going to lie. [35:08] Every dimension of our work is being redefined. [35:10] We need to flex our creativity more than ever, right? [35:13] We need skills to tackle problems [35:15] like context management, token economics, model drift. [35:19] We need creativity. [35:20] And we can't get so hung up on the temptation [35:22] to optimize everything. [35:24] We need to encourage exploration. [35:27] There is a problem that's been keeping me up [35:28] at night that I know can't be solved by just optimizing it. [35:31] And that is, how are we going to maintain intellectual control [35:33] over our code bases as we grow? [35:35] Intellectual control, by the way, [35:36] is just a fancy way of saying, can humans [35:38] reason about this thing in front of them? [35:40] We've been losing this war for at least the last 15 years. [35:43] Our largest systems are way bigger than any of us [35:45] can think about today. [35:46] That's OK. [35:47] I think AI offers us an opportunity. [35:50] I think AI might give us the tools [35:51] to actually begin to understand these very [35:54] large systems as whole systems. [35:57] And if, for example-- or not example. [36:00] If by chance you don't believe me [36:02] when I tell you that we've been losing this war, [36:04] let me suggest an exercise to you. [36:05] When you go back to your team, ask everyone [36:07] to draw an architecture diagram for your system. [36:09] See how many different pictures you get, right? [36:11] We have been losing this war for a long time. [36:13] So we're going to need help. [36:15] The thing is, a lot of our software systems [36:17] are really brittle. [36:18] You can break a million line system with one bad line [36:20] of code or one bad config flag. [36:23] That's the kind of fragile that really [36:25] makes you think twice before you go about making changes. [36:27] One potential use of AI that I've been really excited about [36:30] is this idea that I can get a continuously updated, almost [36:33] interactive architectural space that I [36:35] can begin to ask questions of. [36:36] Like, what would happen if we took capacity from here [36:38] and moved it to the East Coast? [36:40] Or what would happen if our user growth suddenly jumped 40%? [36:43] Doing that for even a modestly-sized system today [36:45] is functionally impossible. [36:46] There's just too many variables and too [36:47] many things you need to know. [36:49] But AI can make sense of very large sets of data. [36:51] So I think there's something there. [36:52] But the thing I like about this problem [36:53] is that, instead of focusing purely [36:55] on making the code machine go, we're asking, [36:57] how can we deepen our understanding of the things [36:59] that we have built? [37:00] That's where I think some of the most exciting problems are. [37:03] Now there's no denying that change is happening really [37:05] fast in our industry. [37:06] And it's happening at a pace probably faster than most of you [37:09] have ever experienced. [37:10] One of the most important things all of you can do right now [37:14] is offer to help someone who is struggling, right? [37:17] Be a helping hand for someone who [37:19] has not figured this out yet. [37:21] We're all moving at different speeds. [37:22] We're all dealing with this change in different ways. [37:25] It is very easy to feel like you're falling behind. [37:27] Senior engineers, be a mentor. [37:30] Find the people who are stuck and help them. [37:32] If you have figured out your AI developer workflow, [37:34] go share it with people. [37:35] It's not a precious secret. [37:37] Help the other people around you. [37:39] If you are a technical lead, you need to get involved. [37:42] You need to help steer how software engineering is [37:44] happening at your company. [37:45] And critically, if you care about software quality [37:49] or software design, you have to use your voice [37:52] to advocate for it. [37:53] You in this room are the people who are going to do that. [37:56] Your bosses probably aren't, right? [37:59] Now at the risk of ending on a somewhat clumsy metaphor, [38:02] if you imagine our developer ecosystems as living ecosystems, [38:05] we have all grown accustomed to staring intently [38:08] at each individual leaf on each individual branch, [38:12] caring for each tree as though it were [38:14] some sort of special life form. [38:16] However, it will not be long before we [38:18] are all not just managing a tree, but an entire forest. [38:21] And you can't manage a forest by looking at individual trees. [38:25] You have to manage a forest by seeing it as an ecosystem. [38:28] Now here's the trouble with systemic change. [38:31] It has this quality of happening to everything, everywhere, [38:34] all at once, of being too big for any of us to influence. [38:39] It can feel, right now, impossible to grab anything [38:42] to steady yourself with the waves of change [38:44] washing up on us, what seems like weekly. [38:47] But as we've just discovered, in a system, [38:50] everything is connected. [38:52] Small actions can have big consequences. [38:55] Despite how it might seem, AI transformation [38:58] is not the sole domain of your company's leaders. [39:00] They have a role to play. [39:01] But so do you. [39:02] As front-line software engineers, [39:04] in this tipping point moment, you [39:06] are at the heart of deciding what software engineering is [39:08] going to be. [39:10] From your tools, to your workflows, [39:11] from your engineering practices, to your engineering culture, [39:14] if you can see the systems at work, you can look for leverage. [39:18] You have more agency than you think. [39:20] You really do. [39:21] Use that agency to create the future for your organization, [39:24] for your team, and for you. [39:27] Thank you. [39:28] [MUSIC PLAYING]