Google Writes 75% of Code With AI, Warns of Verification Bottleneck

Build core skills to thrive as an AI-era developer — Google for Developers

Google for Developers

Surging AI code generation turns evaluation into software engineering's primary bottleneck, threatening catastrophic technical debt and developer burnout unless organizations abandon raw volume metrics to focus on system design and intent.

AI-assisted summary of Build core skills to thrive as an AI-era developer — original source. Check the original for full context.

Source published:

Key ideas

  • Inside Google, 75% of all code is now written by AI, yet telemetry reveals that top-performing engineers spend more time coding, ideating, and collaborating rather than stepping back from their craft. (1:26)
  • The primary development bottleneck has shifted from syntax generation to verification, requiring engineers to construct rigorous environments and automated feedback loops rather than relying on manual inspection or 'vibe coding'. (16:35)
  • Google's internal research shows no increase in system outages despite massive code generation spikes, attributed to tiered risk environments, rigorous automated shepherding agents, and deep platform engineering abstractions. (30:53)
  • The traditional T-shaped engineer must expand horizontally into AI engagement, adjacent engineering (security, reliability, platforms), and non-engineering domains like direct user empathy and business value translation. (11:55)

Detailed notes

## Background Published on YouTube by Google for Developers on May 21, 2026, as part of Google I/O 2026, this presentation features Developer Intelligence leads Nicole Forsgren and Andrew Macvean. The session description highlights the essential skill domains—spanning core engineering principles and business context—required to leverage AI as an effective collaborator and achieve major productivity gains in daily development workflows.

## TL;DR Drawing on internal telemetry and DORA research, Andrew Macvean and Nicole Forsgren demonstrate how software engineering is evolving into an expanded T-shaped discipline rather than disappearing, even as AI generates three-quarters of Google's code. High-performing developers avoid superficial 'vibe coding' by shifting left on intent, writing explicit specification files, and orchestrating multi-agent teams with strict evaluation guardrails. Because code verification has replaced generation as the primary engineering bottleneck, deep technical depth, robust platform engineering, and business empathy are more crucial than ever. Ultimately, the speakers warn that AI acts as an amplifier of organizational health, urging leaders to ditch vanity velocity metrics and curb developer cognitive load to prevent burnout.

## Atmosphere & style The presentation strikes an authoritative, research-grounded, and deeply empathetic tone that directly acknowledges developer anxiety without descending into uncritical AI hype. Forsgren and Macvean maintain a polished, collaborative tag-team rhythm, balancing hard data and internal Google case studies with candid observations on engineering culture and developer well-being. Watching the talk feels clarifying and stabilizing, moving viewers from an initial sense of overwhelming technological whiplash into a pragmatic, empowering vision of elevated software craftsmanship.

## Bulletin - [01:26](https://www.youtube.com/watch?v=q_Jq4IgYImk&t=86s) Inside Google, 75% of all code is now written by AI, yet telemetry reveals that top-performing engineers spend more time coding, ideating, and collaborating rather than stepping back from their craft. - [16:35](https://www.youtube.com/watch?v=q_Jq4IgYImk&t=995s) The primary development bottleneck has shifted from syntax generation to verification, requiring engineers to construct rigorous environments and automated feedback loops rather than relying on manual inspection or 'vibe coding'. - [30:53](https://www.youtube.com/watch?v=q_Jq4IgYImk&t=1853s) Google's internal research shows no increase in system outages despite massive code generation spikes, attributed to tiered risk environments, rigorous automated shepherding agents, and deep platform engineering abstractions. - [11:55](https://www.youtube.com/watch?v=q_Jq4IgYImk&t=715s) The traditional T-shaped engineer must expand horizontally into AI engagement, adjacent engineering (security, reliability, platforms), and non-engineering domains like direct user empathy and business value translation.

## Key takeaways - [01:26](https://www.youtube.com/watch?v=q_Jq4IgYImk&t=86s) AI adoption is pervasive across technology, but DORA research reveals a productivity paradox where individual developer output gains can degrade team-wide delivery if systemic alignment is neglected. - [03:28](https://www.youtube.com/watch?v=q_Jq4IgYImk&t=208s) Unlocking genuine productivity gains requires integrating AI across the entire software development lifecycle rather than treating models as simple code-completion tools pasted onto legacy workflows. - [05:35](https://www.youtube.com/watch?v=q_Jq4IgYImk&t=335s) Top-performing AI-native developers 'shift left on intent' by investing human effort into explicit specification files and operational constraints, turning specs rather than code into the primary source of truth. - [08:20](https://www.youtube.com/watch?v=q_Jq4IgYImk&t=500s) High-performing engineers reject unstructured 'vibe coding' in favor of environment design, building guardrails, reasoning protocols, and multi-agent debate frameworks to achieve verified, high-quality output. - [08:20](https://www.youtube.com/watch?v=q_Jq4IgYImk&t=500s) AI enables the rise of agile 'micro-teams' where traditional job titles decouple from individual tasks, allowing compact pods to ship enterprise-scale software with minimal coordination overhead. - [11:55](https://www.youtube.com/watch?v=q_Jq4IgYImk&t=715s) The evolving T-shaped engineer requires a new horizontal capability for steering AI, alongside broader understanding of adjacent technical domains and non-engineering business context. - [14:36](https://www.youtube.com/watch?v=q_Jq4IgYImk&t=876s) Platform engineering abstracts low-level syntax so non-engineers can ship production experiments, requiring core developers to operate higher up the stack to precision engineer reliability, scale, and safety guardrails. - [16:35](https://www.youtube.com/watch?v=q_Jq4IgYImk&t=995s) To prevent cognitive and technical debt from compounding, engineers must follow the principle of delegating tasks rather than judgment to authoritative-sounding AI models. - [19:18](https://www.youtube.com/watch?v=q_Jq4IgYImk&t=1158s) Google developers preserve deep technical sharpness through deliberate practices like requiring models to tear down and re-implement code, analog whiteboarding walkthroughs, and explicitly codifying rules into skill files. - [22:01](https://www.youtube.com/watch?v=q_Jq4IgYImk&t=1321s) Engineering has shifted from single-prompt enhancement to AI-native orchestration, where humans supervise asynchronous agent teams while balancing automation advantages against verification costs. - [24:17](https://www.youtube.com/watch?v=q_Jq4IgYImk&t=1457s) Google deploys CI/CD shepherding agents and automated review agents to filter routine reliability and security checks, escalating only complex trade-offs and high-risk diffs to human judgment. - [25:52](https://www.youtube.com/watch?v=q_Jq4IgYImk&t=1552s) Successful multi-agent architectures depend on structured evaluation design (evals), agent journaling to capture failure traces, spec-driven development, and tightly scoped agent teams of three to five specialized roles. - [29:26](https://www.youtube.com/watch?v=q_Jq4IgYImk&t=1766s) AI functions as both an amplifier and an unforgiving mirror: it accelerates high-quality internal platforms but rapidly compounds hidden technical debt across fragmented tooling or brittle systems. - [30:53](https://www.youtube.com/watch?v=q_Jq4IgYImk&t=1853s) Tiered risk environments and red-team testing agents allow teams to achieve 10x delivery velocity without introducing 10x operational risk or compromising global production stability. - [35:00](https://www.youtube.com/watch?v=q_Jq4IgYImk&t=2100s) Engineers must act as 'value translators,' transforming ambiguous customer feedback and business goals into explicit technical constraints while resisting the complete replacement of authentic user contact with AI summaries. - [41:28](https://www.youtube.com/watch?v=q_Jq4IgYImk&t=2488s) Leadership cannot solve organizational dysfunction by mandating T-shaped developers; leaders must replace vanity metrics like pull request counts with business outcomes, protect time for productive struggle, and foster blameless psychological safety.

## Detailed walkthrough ### [00:00](https://www.youtube.com/watch?v=q_Jq4IgYImk&t=0s) The Magnitude of the AI-Native Era and the T-Shaped Engineer

Andrew Macvean kicks off the session by taking the pulse of the room, asking the audience whether they feel excited, overwhelmed, or curious. Acknowledging that everyone is likely feeling a mix of all three, he introduces himself and Nicole Forsgren as leads on Google's Developer Intelligence Team. Together, they have spent their careers systematically studying software engineers—analyzing the people, processes, tooling, systems, and overarching culture that shape how software gets built. Macvean emphasizes that the industry is living through a monumental inflection point, characterized not only by the sheer magnitude of change but by the unprecedented speed at which it is occurring.

The primary objective of the talk is to draw upon internal research and insights from inside Google to tackle a central question facing the industry. Rather than framing artificial intelligence as a replacement for human developers, the speakers focus on how engineers can adapt and thrive alongside it. Central to this evolution is the rising prominence of an expanded, T-shaped software engineering role that pairs technical depth with broad context, requiring developers to embrace new collaboration patterns, hone specific high-leverage capabilities, and reconsider the everyday mechanics of their work.

> “How can we, as software engineers, continue to thrive in the AI-native era?” — Andrew Macvean

[01:26](https://www.youtube.com/watch?v=q_Jq4IgYImk&t=86s) Pervasive Adoption, the Productivity Paradox, and Counterintuitive Coding Habits

Setting the baseline reality of the modern development landscape, Macvean notes that AI tool adoption is already pervasive across the technology sector. Within Google specifically, the scale of integration is immense: three-quarters of all code is now written by AI. Yet, despite this massive footprint, organizations and leaders are wrestling with whether these tools genuinely deliver real productivity gains, and if so, whether the improvement is on the order of 10%, 10x, or 100x. In many organizations, a curious productivity paradox has surfaced. Research conducted by Google's DORA (DevOps Research and Assessment) team across multiple enterprises revealed that while AI adoption frequently boosts perceived individual developer productivity, it can simultaneously degrade team-level outcomes if system dynamics are neglected.

Inside Google over the past year, however, distinct positive patterns have emerged under the right conditions. When developers operate within intentional systems and well-architected environments, autonomous code generation does not produce disposable junk; rather, the code actually lasts. Furthermore, the telemetry reveals counterintuitive behavioral trends among Google's top-performing engineers. Rather than stepping back from the craft as AI takes over low-level tasks, the developers who rely most heavily on AI actually spend more time coding, more time ideating, and more time collaborating with their peers. While the fundamental shape and cadence of these activities have transformed, elite engineers are becoming more engaged rather than less.

> “Our top-performing engineers, they're more active, not less, even though they're delegating more and more work to AI.” — Andrew Macvean

- **Three-quarters of code written by AI**: Inside Google, 75% of all code generated across systems is authored by artificial intelligence. - **The DORA productivity paradox**: Research shows that without organizational alignment, gains in individual developer output can inadvertently result in net decreases in team-wide delivery and performance. - **Amplified core activities**: Top AI users at Google record higher volumes of active coding, creative ideation, and peer collaboration compared to lower-adopting counterparts.

[03:28](https://www.youtube.com/watch?v=q_Jq4IgYImk&t=208s) Beyond Code Generation: Whole-Lifecycle Transformation and Reassurance

Macvean cautions that the benefits of AI are never homogeneous, pointing back to the foundational computing adage of "garbage in, garbage out." Capturing real value requires deep mastery not just of prompt mechanics, but of the specific domain and context where AI is applied. Software engineering has always encompassed vastly more than typing syntax, and raw coding speed was never the genuine bottleneck in product delivery. Unlocking the true promise of AI therefore hinges on two realizations: first, AI must be integrated across the entire software and product development lifecycle rather than treated as a mere code-completion engine; second, teams cannot simply paste AI onto legacy workflows. Groundbreaking value occurs only when traditional development processes are fundamentally rethought, giving rise to brand-new roles and workflows.

To comfort an audience navigating this intense transition, Macvean offers two reassuring messages. First, developers experiencing anxiety, confusion, or emotional fatigue are far from alone; internal and external research confirms that developers worldwide are wrestling with complex, conflicting emotions given the sheer velocity of the transition. Second, there is a clear, repeatable path forward. While no silver bullet exists, intentional adaptation enables developers to rise above the churn and establish fulfilling, high-impact careers.

> “We're seeing strong evidence that despite the new shape of the software engineering role, when the change is approached intentionally, this really can and should be the most exciting time to work in this field.” — Andrew Macvean

```mermaid flowchart TD accTitle: Holistic AI Product Development Lifecycle accDescr: Diagram contrasting narrow code generation with end-to-end product lifecycle transformation using AI.

subgraph Legacy["Narrow AI Adoption"] A["Legacy Process"] --> B["AI Code Generation"] B --> C["Downstream Bottlenecks"] end

subgraph Holistic["Transformed Lifecycle"] D["User Needs & Business Context"] --> E["Structured Intent & Specs"] E --> F["AI Agent Execution & Reasoning"] F --> G["Verified End-to-End Delivery"] end ```

[05:35](https://www.youtube.com/watch?v=q_Jq4IgYImk&t=335s) Patterns of Top Performers: Operating at Altitude and Shifting Left on Intent

Nicole Forsgren steps up to detail the concrete behaviors observed among Google's highest-performing, AI-native software engineers. In her team's work measuring the complete engineering system—tracking end-to-end cycle time from the raw seed of an idea to live software in users' hands—five key patterns stand out. The first pattern is that elite engineers consistently operate at higher altitudes. Rather than focusing solely on implementation mechanics, they fuse core technical acumen with a deep comprehension of business context and user needs. While senior engineers have historically been expected to grasp the business rationale behind their work, the presence of AI accelerating raw execution makes mastering the "why" more critical than ever.

The second pattern represents a fundamental evolution of a familiar engineering concept: shifting left on intent. Historically, "shifting left" meant migrating quality assurance, testing, or security reviews earlier into the development pipeline. In an agentic era where autonomous models handle the bulk of execution, shifting left requires front-loading human energy into defining clear intent, architectural trade-offs, constraints, and operational context. Consequently, the primary source of truth is moving away from the code repository itself and migrating into structured specification files. These living spec files make product thinking explicit, giving agents the necessary rationale to make sound decisions while preventing severe cognitive overload and rescuing teams from building prototypes whose underlying logic no one understands.

> “What this means is that a fundamental source of truth is moving away from the code itself.” — Nicole Forsgren

> “Our engineers are writing specification files, which, if we think about it, is really product thinking made explicit.” — Nicole Forsgren

- **Higher altitudes of execution**: Prioritizing the underlying business purpose and user impact over syntax, answering why a system should be built before deciding what or how. - **Redefining shift-left**: Transitioning from shifting left on testing and security to shifting left on human intent, constraints, and trade-offs. - **Specification files as artifacts**: Creating explicit documentation of product reasoning and constraints that acts as the steering guide for autonomous agents. - **Cognitive overload prevention**: Structuring evolving project knowledge systematically up front to avoid accumulating inscrutable prototypes and technical debt.

[08:20](https://www.youtube.com/watch?v=q_Jq4IgYImk&t=500s) Designing Environments over Vibe Coding, Micro-Teams, and Continuous Exploration

Moving into the third pattern, Forsgren stresses that Google’s top engineers are emphatically not "vibe coding" or casually flinging prompts at a model in hopes of receiving functional code. Instead, high-performing developers act as environment designers. They construct rigorous systems of reasoning, establish operational guardrails, and supply domain context so that human developers and autonomous agent teams can collaborate toward broad objectives at scales far exceeding individual capacity. Because elite engineers demand verified, high-quality code rather than merely fast code, these structured environments dictate how agents act, establish automated feedback loops, and even define protocols for agents to debate one another to stress-test architectural alternatives.

The fourth pattern highlights how AI is fundamentally decoupling traditional job titles from the actual tasks individuals can execute. This shift has accelerated the rise of "micro-teams"—small, highly agile, cross-functional pods that operate with minimal communication overhead and rapid internal feedback loops. Empowered by fleets of specialized agents, these compact units ship at remarkable velocity and scale. However, Forsgren notes that successful delegation to agent teams remains entirely contingent on shifting left on intent: developers must clearly delineate constraints, success criteria, and historical learnings so agents do not repeat past mistakes. Finally, Forsgren introduces the fifth and final emerging pattern: cultivating a disciplined scientific mindset grounded in continuous, deliberate exploration.

> “What they're doing is they're designing environments.” — Nicole Forsgren

> “They don't just want fast code. They want verified, high-quality code.” — Nicole Forsgren

- **Environment design over vibe coding**: Shifting focus from ad-hoc prompting to engineering structured reasoning platforms, guardrails, and multi-agent debate environments. - **Agent delegation with guardrails**: Ensuring autonomous agents have access to relevant tools, datasets, and explicitly documented trade-offs to keep engineering quality high. - **Rise of the micro-team**: Small cross-functional pods leveraging agents to eliminate inter-team coordination bottlenecks and execute at large enterprise scale. - **Scientific mindset**: Approaching the rapidly shifting AI toolchain with an experimental, hypothesis-driven posture of ongoing learning.

[10:33](https://www.youtube.com/watch?v=q_Jq4IgYImk&t=633s) Shift Left, Shift Up, and System Design

Working at the cutting edge requires teams to normalize failure. Because the technology landscape changes rapidly, success is rarely about getting things right on the first try; it centers on learning while moving, iterating, and feeding those lessons into the broader organization. Every week, engineers run new experiments and deliberately codify those takeaways back into the system. As the speakers emphasize:

> “It isn’t a scientific mindset if we just randomly explore and we never capture and apply those learnings.”

This approach weaves together three core concepts: shifting left, shifting up, and holistic system design. System design encompasses the surrounding environment, the actors operating within it—humans, autonomous agents, and developer tools—and the underlying culture holding them together. By aligning these elements, teams can concentrate on high-impact problems, adapt rapidly, execute cleanly, and continuously channel feedback back into the system.

```mermaid flowchart LR accTitle: Learning Feedback Loop in System Design accDescr: A continuous cycle showing how experimentation feeds into system design and codification. subgraph Execution["System Design & Execution"] A["Actors: Humans, Agents, Tools"] --> B["Environment & Culture"] B --> C["Shift Left & Shift Up"] end subgraph Feedback["Continuous Learning Loop"] C --> D["Weekly Experiments"] D --> E["Codify Learnings"] E --> A end ```

[11:55](https://www.youtube.com/watch?v=q_Jq4IgYImk&t=715s) The Evolving T-Shaped Developer in the AI Era

To identify the core skills required to thrive in an AI-native era, the speakers revisit the traditional model of the T-shaped engineer. Historically, the horizontal bar of the T denotes a broad working knowledge across the wider software ecosystem—understanding how key components fit together without needing mastery in every domain—while the vertical stem represents deep, specialized expertise in a particular framework, technology stack, or vertical (such as fintech).

In the AI era, this T-shape is undergoing a significant evolution. A brand-new horizontal layer is now mandatory: engaging effectively with AI. Engineers must intimately understand the constraints of AI in specific task contexts, rigorously evaluate output quality, and steer models productively. Furthermore, the wings of the horizontal bar must expand into two adjacent domains: 1. **Adjacent engineering:** As AI drives higher code throughput and generates more functional code, engineers must maintain a sharp grasp of architectural trade-offs, scalability, and system integration. 2. **Adjacent non-engineering (business and user context):** Because AI automates the mechanical "how" of writing code, engineers must focus heavily on the "why"—the business, product, and end-user needs being addressed.

While senior developers have traditionally operated with this wider scope, AI now forces engineers at all levels to operate at higher altitudes alongside agents. As Nicole Forsgren warns:

> “Otherwise, AI can just make us do wrong things faster.”

[14:36](https://www.youtube.com/watch?v=q_Jq4IgYImk&t=876s) Scaling Abstractions: Platform Engineering and Core Skills

Andrew Macvean takes over to unpack how core software engineering skills are transforming inside Google, sharing an anecdote from the Search organization. Non-engineer product managers (PMs) in Search are currently shipping product features all the way through to live production experiments without writing traditional code. Instead, they use internal platform tooling that translates their business and user intent directly into functional production features.

```mermaid flowchart TD accTitle: Platform Abstraction for AI-Era Development accDescr: Shows how PMs translate intent to features while engineers build the underlying platform. PM["Product Managers (Intent)"] -->|"Translate intent"| Plat["Internal AI Platform"] Plat -->|"Live experiments"| Prod["Production Tech Stack"] Eng["Core Software Engineers"] -->|"Precision engineer guardrails, scale, reliability"| Plat ```

From the outside, this might prompt the question of whether traditional engineering skills still matter if PMs can ship features independently. However, Macvean explains that this capability is possible only because of an exceptionally advanced platform. The deep system architecture knowledge, language frameworks, scalability rules, and reliability constraints are all baked into that platform by engineers. Rather than handcrafting individual features, the engineer is operating higher up the abstraction stack, precision engineering the ecosystem that allows features to deploy safely—a task that requires more technical depth, not less.

[16:35](https://www.youtube.com/watch?v=q_Jq4IgYImk&t=995s) Precision Engineering Over "Vibe Coding"

As code generation accelerates, verification threatens to become the primary development bottleneck. While AI serves as a powerful multiplier, engineers must possess the technical depth required to evaluate, integrate, and maintain its output. Because line-by-line manual verification is cognitively impossible at scale, teams must construct automated feedback loops in low-stakes environments to catch defects reliably and direct developer attention exclusively where it adds the most value.

Macvean stresses that top engineers do not simply accept AI output blindly; as he puts it, “Our engineers, they don't vibe code. They control.” Without deep domain understanding, AI rapidly compounds technical and cognitive debt. Engineers must establish strict guardrails—such as programmatic checks that catch model drift or enforce nuanced style-guide rules. Highlighting the need to resist intellectual passivity when interacting with convincing, authoritative-sounding models, Macvean emphasizes:

> “There's a saying I like-- delegate tasks, not judgment.”

- **Verification as a bottleneck:** Rapid generation requires automated testing, performance data collection, and safety guardrails rather than exhaustive manual line-by-line inspection. - **Cognitive and technical debt:** Relying on unverified, surface-level AI output risks introducing hidden system degradation at massive speed. - **Continuous observability:** Instrumentation and telemetry reveal where agents make false assumptions due to missing context or where safety guardrails are lacking.

[19:18](https://www.youtube.com/watch?v=q_Jq4IgYImk&t=1158s) Practical Habits to Build and Maintain Deep Technical Expertise

To actively maintain deep engineering expertise while moving quickly, Google's top teams implement three concrete practices:

1. **Re-implementation as a learning tool:** Rather than accepting an AI model's first solution, engineers explicitly instruct the model to tear down the initial draft and re-implement it using an alternative approach. The engineer prompts the AI to document its reasoning, explain why it made different design choices, and detail what it learned. This surfaces flawed initial assumptions, highlights missing context, and forces consideration of alternative design trade-offs. 2. **Walkthroughs of alien code and agent decision traces:** Teams conduct structured walkthroughs of code and architectures generated by AI agents or other developers that the reviewing engineers did not write themselves. To reinforce a shared mental model of the system, teams frequently turn to analog techniques—particularly whiteboarding. In this environment, raw code is no longer the primary deliverable; shared understanding and adherence to user intent are the deliberate outcomes. 3. **Explicit codification via rule and skill files:** Teams increasingly document their engineering standards, conventions, and architectural guardrails within dedicated skill and rule files, making expectations transparent to both human teammates and autonomous agents.

[20:57](https://www.youtube.com/watch?v=q_Jq4IgYImk&t=1257s) Context Engineering at Scale and Structured Agent Role Profiles

Andrew Macvean details how top teams at Google move beyond off-the-shelf, out-of-the-box AI solutions to achieve context engineering at scale with greater reliability. Instead of treating AI agents as simple prompt responders, the best teams create, curate, and maintain structured agent role profiles. These profiles define very specific behavioral attributes and provide explicit "recipes" and domain knowledge needed to work effectively inside complex engineering systems.

```mermaid flowchart TD accTitle: Agent Context and Profile Lifecycle accDescr: Process showing how agent profiles and recipes are version-controlled, observed, and updated via feedback loops. subgraph Governance["Engineering Governance"] VC["Version Control"] Obs["Observability Practices"] end subgraph Engineering["Agent Role Profiles"] AP["Structured Role Profiles<br/>& Behavioral Attributes"] R["System Specs & Recipes"] end subgraph Execution["System & Feedback"] Sys["Internal Codebase & Execution"] FL["Feedback Loops<br/>(What works vs. what doesn't)"] end VC --- AP Obs --- R AP --> Sys R --> Sys Sys --> FL FL -->|"Reflect & Refine"| AP ```

Macvean explains that this discipline serves a dual purpose: it grounds the agents while sharpening the developers' own software craftsmanship. When engineers are forced to define concrete operational parameters for autonomous systems, it reinforces core architecture and design skills:

> “Again, being forced to consistently reflect on what good looks like-- what is a good behavior from an agent? That's a really good way to remain sharp in your core engineering skills.”

- Teams must treat agent skills, rules, and system specifications exactly like production code, backing them with proper version control and observability practices. - Codifying agent behaviors creates active feedback loops that show what works, what fails, and how to incrementally increase agent effectiveness.

---

[22:01](https://www.youtube.com/watch?v=q_Jq4IgYImk&t=1321s) From AI Enhancement to AI-Native Orchestration

Nicole Forsgren takes the stage to discuss how generative AI usage has shifted inside Google. The paradigm has evolved beyond mere "AI enhancement" into genuine "AI-native engineering." Developers are no longer individual conductors managing a single prompt-driven agent; they have become system orchestrators managing entire teams of asynchronous, decoupled AI agents. Each agent operates with its own dedicated context window and strict area of responsibility, while the supervising human engineer sets up the environment, guides the workflow, and establishes baseline rules.

```mermaid flowchart TD accTitle: Orchestrating Asynchronous AI Agent Teams accDescr: An engineer orchestrates specialized agents, balancing automation against verification cost. Eng["Human Software Engineer<br/>(Sets Environment & Directs Flow)"] subgraph AgentTeam["Asynchronous Agent Team"] A1["Agent 1<br/>(Isolated Context / Domain A)"] A2["Agent 2<br/>(Isolated Context / Domain B)"] A3["Agent 3<br/>(Isolated Context / Domain C)"] end Eng -->|"Delegates Tasks"| A1 Eng -->|"Delegates Tasks"| A2 Eng -->|"Delegates Tasks"| A3 AgentTeam --> Verif{"Verification Overhead<br/>Evaluation Cost Bottleneck"} Verif -->|"High Confidence"| Automated["Autonomous Progress"] Verif -->|"High Risk / Edge Cases"| HumanEval["Human Attention & Judgment"] ```

Forsgren emphasizes that orchestration requires mastering when to delegate and when to withhold delegation. Without this discipline, teams fall directly into the "automation trap." Top-performing teams establish clear human baselines and rigorously calculate the verification overhead of checking AI-generated code against the cost of performing the work manually. To maximize returns, engineers run controlled experiments, delegating only tasks with a high probability of success while reserving human cognition for ambiguous problems, architectural taste, and critical judgment.

Because evaluation cost has become the primary bottleneck in software engineering, engineers must lean heavily into systems thinking:

> “Where we don't see enough success, we start analyzing agent traces and we build a shared understanding of where our system can improve, whether it's something like the usability of tools that the agents aren't using or the skills that agents themselves have been equipped with.”

- Teams deploy adversarial review agents to intentionally stress-test system boundaries, critique decisions, and uncover edge cases. - Execution traces from adversarial runs are captured and analyzed to update agent instructions, intent, and tool integrations. - Orchestration requires a paired skill set: a deep understanding of the underlying software architecture coupled with an intuitive grasp of the model’s specific strengths, weaknesses, and failure modes.

---

[24:17](https://www.youtube.com/watch?v=q_Jq4IgYImk&t=1457s) Automated Code Review and CI/CD Shepherding Agents

With substantial growth in code volume across Google's repositories, internal engineering teams rely heavily on automated code review agents. Rather than seeking to replace human peers, these agents aim to accelerate feedback loops by evaluating functionality, reliability, performance, usability, security, and maintainability as early as possible. If an agent identifies flawed assumptions, the issue is logged and fed back into the system, protecting human reviewers from cognitive exhaustion on basic verification tasks.

```mermaid flowchart LR accTitle: CI/CD Shepherding Pipeline accDescr: Shepherding agent guides code changes through review agents and risk assessment before human sign-off. PR["In-Flight Code Change"] --> Shep["Shepherding Agent<br/>(CI/CD Pipeline)"] subgraph Checks["Automated Quality & Safety"] Shep --> Rev["Code Review Agents<br/>(Reliability, Usability, Security)"] Shep --> Risk["Risk Assessor Agents<br/>(Calculates Change Risk)"] end Rev --> Result{"Meets Baseline?"} Risk --> Result Result -->|"High-Risk / Trade-offs"| Human["Human Reviewer<br/>(Judgment & Taste)"] Result -->|"Passes Verification"| Merge["Pipeline Progression"] ```

To coordinate this pipeline, Google built specialized "shepherding agents" to steer pending commits through continuous integration and continuous delivery (CI/CD) workflows. These shepherding agents repeatedly trigger review agents and route commits through risk assessor agents, which inspect in-flight changes and escalate dangerous, complex, or high-risk diffs directly to senior human engineers.

Forsgren highlights a guiding philosophy for this division of labor:

> “Of course, I come back to the need for software engineers to delegate tasks, not judgment.”

- Engineers define team-specific definitions of soft attributes like maintainability and usability, which vary substantially across different production systems. - Humans make architectural trade-offs when qualities conflict (such as balancing extreme performance against readability or usability). - AI surfaces trade-offs and highlights risks, but final authority remains human.

---

[25:52](https://www.youtube.com/watch?v=q_Jq4IgYImk&t=1552s) Four Core Practices: Evals, Journaling, Multi-Agent Teams, and Specs

Forsgren outlines four practical techniques for upskilling developers and adapting organizational architectures for autonomous agents:

```mermaid flowchart TD accTitle: Four Core Practices for Agentic Engineering accDescr: Four essential pillars for building effective agentic workflows: Evals, Journaling, Agent Teams, and Spec-Driven Development. subgraph Practices["Pillars of Agentic Engineering"] P1["1. Upskill on Evals<br/>(Combines AI + Domain Expertise)"] P2["2. Agent Journaling<br/>(Daily Reflection on Blockers & Tools)"] P3["3. Balanced Teams of Agents<br/>(Planner, Orchestrator, Coder)"] P4["4. Spec-Driven Development<br/>(Clear Goals, Constraints & Rationale)"] end ```

1. **Upskill on Evals:** With verification standing as the main engineering bottleneck, developers must master evaluation design. Creating grounded, relevant evals requires a T-shaped engineer with cross-functional software, product, and business understanding. Evals act as a core artifact that preserves team intent and defines what "good" looks like. 2. **Implement Agent Reflection (Agent Journaling):** Beyond personal post-mortems, engineers require agents to record detailed trace journals at the end of runs. Engineers examine where the agent got stuck, misread prompt instructions, or encountered friction. These reflections reveal not only where prompt instructions need tightening, but also broader infrastructure flaws, such as brittle internal APIs or poor tool usability. 3. **Build Multi-Agent Teams:** Scaling past single prompts requires strict multi-agent architectures. For delicate, high-complexity migrations inside Google—such as TensorFlow upgrades across production services—teams avoid generic chatbots. Instead, they implement a dedicated three-tier setup: - A **Planner Agent** that breaks migrations down into discrete, verifiable steps. - An **Orchestrator Agent** that groups and sequences the steps. - A **Coder Agent** that executes the code modifications. - These agents ingest tailored product playbooks so that a migration in a service like YouTube automatically adheres to YouTube-specific engineering rules and coding styles. - While multi-agent tooling is expanding, Forsgren notes that keeping teams between three and five agents represents the current sweet spot for maintainability and avoiding uncontrolled "agent sprawl." 4. **Practice Spec-Driven Development:** Vague, conversational prompting fails at scale. High-quality agentic systems demand precision engineering where product requirements, constraints, and architectural rationales are documented thoroughly upfront. Combined with clear agent roles, specifications serve as the definitive single source of truth for the system's design and intent.

---

[29:26](https://www.youtube.com/watch?v=q_Jq4IgYImk&t=1766s) The Adjacent Engineering Wing: Internal Platforms as Amplifiers

Macvean shifts the discussion to adjacent engineering capabilities—cybersecurity, privacy, deployment infrastructure, and industry compliance—which interface directly with AI systems. When applied over solid engineering foundations, AI acts as an accelerator. Conversely, applying AI across broken tooling or fragmented systems rapidly compounds architectural failure.

```mermaid flowchart TD accTitle: AI as an Amplifier and a Mirror accDescr: Showing how AI magnifies underlying engineering quality into accelerated delivery or compounded technical debt. AI["AI Capabilities"] subgraph Strong["High-Quality Internal Platforms"] S1["Clean APIs"] S2["Documented Workflows"] S3["Robust Infrastructure"] end subgraph Weak["Fragmented Architecture"] W1["Siloed Data"] W2["Fragile Infrastructure"] W3["Brittle Tooling"] end Strong --- AI --> ResultA["Powerful Collaborator<br/>& Accelerated Delivery"] Weak --- AI --> ResultB["Quiet, Catastrophic Debt<br/>Generated Faster"] ```

Macvean references findings from Google's DevOps Research and Assessment (DORA) team to caution developers against viewing AI as a substitute for disciplined engineering foundations:

> “AI is an amplifier, and it is a mirror. It magnifies those existing strands while it holds up a mirror to those weaknesses. The adjacent engineering wing, this is where AI is most likely to introduce quiet, catastrophic debt if it's left unchecked.”

- Solid internal platforms, hardened APIs, and documented engineering workflows enable AI to act as a powerful collaborator. - In uncurated, brittle environments with siloed data, AI accelerates the accumulation of technical debt rather than resolving it. - Reflecting back on Search product managers building features, Macvean notes that embedding operational best practices directly into shared internal platforms allows teams to deliver new capabilities safely without handcrafting and verifying every individual line of code.

[30:53](https://www.youtube.com/watch?v=q_Jq4IgYImk&t=1853s) Adjacent Engineering Skills: Tiered Environments and Mitigating Risk

Scaling AI-generated code demands a wide array of adjacent engineering capabilities, such as mastering deployment environments, security requirements, and system reliability alongside foundational programming skills. Andrew Macvean points out an encouraging internal benchmark at Google: despite the massive uptick in code produced by AI, there has been no measurable rise in outages or drop in system reliability. The central operating principle is striking a deliberate balance: “What we want is 10x the velocity without 10x the risk.”

To realize this goal, teams rely on tiered risk environments that respect the differing operational constraints of different software. An internal utility does not carry the same scaling or availability requirements as a system serving a billion users. Moving iteratively from prototype to production through graded risk stages isolates the blast radius while maintaining tight, rapid feedback loops. This framework directly enables effective experimentation, giving teams a principled way to isolate new features in production, measure their real-world impact, and evaluate critical architectural trade-offs without endangering global stability.

```mermaid flowchart LR accTitle: Tiered Risk Progression Pipeline accDescr: Progression of software delivery from prototype to production through isolated environments. subgraph Ideation["Stage 1: Exploration"] Proto["Prototype Environment"] end subgraph Validation["Stage 2: Isolation"] Internal["Internal Apps & Staging<br/>(Limited Blast Radius)"] end subgraph Rollout["Stage 3: Production"] Prod["Tiered Production<br/>(Global Scale & Monitoring)"] end Proto --> Internal Internal --> Prod ```

---

[32:23](https://www.youtube.com/watch?v=q_Jq4IgYImk&t=1943s) Four Practices to Strengthen System Resilience and Observability

To cultivate operational excellence in an AI-accelerated workflow, high-performing teams lean into four core disciplines:

1. **A Culture of Blame-Free Postmortems:** Resilient engineering depends on consistently documenting, reviewing, and discussing system outages. Analyzing failures sharpens intuition around edge cases, scaling bottlenecks, and availability threats. Furthermore, these postmortems provide vital ground truth when steering automated tools; engineers can triangulate postmortem findings with an agent’s internal self-reflections and observability traces to pinpoint gaps in instructions or exposed edge cases. 2. **Employing Red-Team Agents to Stress-Test:** AI should not merely generate code; it must be deployed to challenge it. By configuring specialized red-team agents, teams observe their architecture through the lens of an attacker. Prompting these agents to articulate how they would penetrate or exploit the environment forces engineers to confront concrete attack vectors, breaking the habit of passively accepting generated solutions. 3. **Analog Mapping on Whiteboards:** Teams are deliberately returning to physical whiteboards and manual data-flow diagrams before touching code. Manually tracing architecture and data pipelines clarifies mental models around enterprise compliance, exposing flawed assumptions early so that generative agents receive properly constrained instructions. 4. **Rich Observability and Unified Data Agents:** When deployment velocity jumps tenfold, robust telemetry is vital to verify behavior in production. Early-career developers often struggle to interpret ambiguous regressions or opaque distributed system metrics. To remove these roadblocks, Google invested in unified data agents integrated with stack traces, source code, performance data, and system logs. These agents assist junior engineers in diagnosing complex distributed failures, exemplifying how AI serves not just as a builder, but as an interpretive diagnostic tool.

---

[35:00](https://www.youtube.com/watch?v=q_Jq4IgYImk&t=2100s) Adjacent Non-Engineering Skills and Developers as Value Translators

The final arm of the T-shaped framework centers on non-engineering competencies: building deep alignment with customer requirements and business outcomes. Because autonomous tools shoulder more repetitive coding tasks, software engineers have the mandate to focus primarily on the "what" and the "why." However, Nicole Forsgren notes that this transition can trigger an identity crisis, as highlighted by DORA research: developers accustomed to evaluating their self-worth through the raw craft of manual coding must intentionally pivot toward the tangible human and business impact of what they ship.

Modern engineers act as "value translators" by converting messy customer feedback and business goals into explicit, unambiguous technical constraints. Rather than allowing an LLM to blindly optimize a slow loop, a value translator asks which specific user cohort is suffering under what conditions, checks telemetry, and directs the AI model to optimize only the critical paths impacting those users. Quoting Peter Senge, Macvean notes:

> “The most effective people are those who can hold their vision while remaining committed to seeing current reality clearly.”

This philosophy crystallizes the modern T-shaped engineer, who marries expansive strategic perspective with uncompromising technical fidelity.

---

[36:55](https://www.youtube.com/watch?v=q_Jq4IgYImk&t=2215s) Blurring Disciplinary Lines and Cross-Functional Fluidity

The shift toward T-shaped capabilities is not isolated to software engineers; product managers, UX designers, and data scientists are undergoing the same transition. Search product managers, for example, no longer wait for designers to supply static mockups before validating concepts; they leverage automated tooling to move directly from an idea to a working prototype on safe platforms engineered by developers.

This expanded agency softens conventional organizational silos. In teams building internal tools, designers, product managers, and software engineers frequently commit and ship code to the same repository. While difficult architectural decisions remain collaborative, a designer who spots a subtle UI papercut can directly patch and deploy the fix without waiting on a dedicated engineering ticket.

```mermaid flowchart TD accTitle: Shared T-Shaped Delivery Loop accDescr: Cross-functional disciplines shipping code together against a shared spec. Spec["Spec-Driven Source of Truth<br/>(Business Logic & Edge Cases)"] subgraph Roles["T-Shaped Roles"] PM["Product Manager<br/>(Live Prototypes)"] ENG["Software Engineer<br/>(Platform & Reliability)"] UX["UX Designer<br/>(Direct UI Fixes)"] end Codebase["Shared Production Codebase"] Spec --> PM Spec --> ENG Spec --> UX PM --> Codebase ENG --> Codebase UX --> Codebase ```

Two specific habits keep these cross-functional workflows grounded: - **Resisting the Complete AI Synthesis of Feedback:** While feeding user feedback into an LLM for summaries is convenient, it risks erasing nuanced sentiment. High-performing teams intentionally participate in live, high-touch user feedback sessions, as hearing authentic user delight or frustration firsthand fosters the deep empathy necessary to steer product direction. - **Spec-Driven Development as the Primary Deliverable:** Teams treat the functional specification as their definitive deliverable. Significant engineering energy is front-loaded into debating business assumptions, system rules, and failure modes in the open before writing implementation code. These formal specifications can then be evaluated by review agents to detect logical contradictions and requirements collisions before execution begins.

---

[39:29](https://www.youtube.com/watch?v=q_Jq4IgYImk&t=2369s) Pulling It Together: Organizational Realities and the Harsh Mirror of AI

Nicole Forsgren integrates the components of the AI-native developer model: - **Deep Core Technical Expertise:** Essential for reviewing, verifying, and catching subtle flaws produced by generative models. - **Agent Orchestration Skills:** Directing fleets of specialized tools while preserving high signal-to-noise ratios. - **Adjacent Engineering Depth:** Navigating telemetry, system architecture, security postures, and deployment pipelines. - **Non-Engineering Context:** Anchoring software delivery to actual business ROI and real user empathy.

Turning her attention to engineering managers and executive leadership, Forsgren stresses that individual technical evolution cannot overcome broken operational environments. Emphasizing the hard truths uncovered by DORA research, she states:

> “Engineers do not work outside of an org, and we don't work alone.”

> “The hard truth is, you can't mandate a T-shaped developer inside of a broken system.”

As Macvean outlined, deploying generative AI inside an enterprise acts as an unforgiving mirror: it amplifies organizational dysfunctions just as quickly as it multiplies the strengths of well-aligned teams operating with mature engineering practices.

[40:41](https://www.youtube.com/watch?v=q_Jq4IgYImk&t=2441s) Cognitive Load and System Bottlenecks in the AI Era

While artificial intelligence has the power to drastically accelerate value delivery, it is fundamentally incapable of compensating for broken organizational foundations. If an organization suffers from fragmented tooling, siloed information, or a toxic culture of blame, AI will not fix those problems; instead, it acts as an amplifier that directly exposes those existing systemic bottlenecks. Invoking W. Edwards Deming’s classic principle, the speaker reminds leaders: “A bad system will beat a good person every time.”

The day-to-day reality for developers is undergoing a drastic transformation that threatens to overwhelm them cognitively. Software engineers are now being asked to concentrate their mental energy on the most difficult architectural choices, rigorously audit and verify machine-generated code, and continuously context-switch across multiple autonomous agents. This constant high-stakes orchestration introduces severe mental friction. Leaders cannot expect teams to deliver massive leaps in productivity if it requires an unsustainable surge in mental strain; as the speaker warns, “10x output cannot come with 10x cognitive load, or that will burn people out.” To help developers safely evolve into an expanded T-shaped role, leadership must fundamentally reshape the engineering environment.

```mermaid flowchart TD accTitle: AI Impact on System Bottlenecks and Cognitive Load accDescr: Diagram illustrating how organizational dysfunction combined with AI leads to developer burnout.

subgraph OrgPillars ["Organizational Foundations"] A["Fragmented Tooling & Siloed Data"] B["Culture of Blame"] end

subgraph DemingLaw ["System Reality"] C["AI Exposes Existing Bottlenecks"] D["High Cognitive Strain:<br>Verifying Output & Context Switching"] end

subgraph Outcomes ["Terminal Impact"] E["Severe Cognitive Exhaustion"] F["Developer Burnout"] end

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

[41:28](https://www.youtube.com/watch?v=q_Jq4IgYImk&t=2488s) Three Critical Leadership Shifts for Engineering Teams

To create an environment where engineers can step into this expanding T-shaped paradigm without burning out, organizations must adopt three immediate cultural and operational shifts:

First, leaders must overhaul how engineering productivity is defined and tracked. Management must abandon legacy vanity signals like throughput, pull request counts, or the number of accepted lines of code, and instead evaluate teams based on delivered business value and customer outcomes. Relying purely on velocity creates hazardous perverse incentives; if an organization tracks speed while ignoring quality, engineers will skip the painstaking verification needed for AI-generated code, causing system instability to spiral out of control. Leaders should instead adopt a balanced portfolio of metrics that counterbalances speed with resilience and quality.

Second, teams must intentionally defend the concept of "productive struggle." Deep comprehension requires time, which means organizations have to dedicate official working hours for engineers to master AI tooling and deeply investigate the architectures they are building. Developers should be encouraged to run manual architectural walkthroughs and test competing tools against varied problem sets to observe how different models respond. Denying developers the breathing room to build these foundational mental models guarantees that teams will eventually drown in unmanageable cognitive debt.

Third, leadership must cultivate radical psychological safety. Because engineering is entering an unmapped era of rapid experimentation, developers will construct agentic workflows that inevitably fail. When an organization penalizes experimentation, developers immediately retreat to safe, antiquated routines and familiar habits. Organizations must instead celebrate intelligent failure and institutionalize blameless postmortems, transforming individual mistakes into collective system-level learning.

- **Redefine productivity metrics:** Eliminate reliance on pull request volume, raw throughput, or lines of code accepted in favor of business outcomes and balanced metrics. - **Protect the productive struggle:** Allocate regular work hours for manual architectural analysis, tool benchmarking, and foundational mental model formation to prevent cognitive debt. - **Instill psychological safety:** Embrace failures in agentic systems through blameless postmortems and intentional celebrations of intelligent experimentation.

[43:07](https://www.youtube.com/watch?v=q_Jq4IgYImk&t=2587s) The Evolving Craft: Shifting Left and Shifting Up

While coordinating an entire workforce of AI agents while simultaneously designing distributed, complex systems might sound daunting, keeping engineers anchored at such a high-altitude decision space does not strip away the core satisfaction of the profession. Even as the nature of an engineer's effort undergoes structural change, the foundational joy of building things remains fully intact. By cultivating an expanded T-shaped skill set, developers experience the thrill of seeing their ideas translate into working reality at speeds never before possible, drawing them closer to the software they envision rather than alienating them from it.

Developers are not being asked to abandon software craftsmanship, but rather to elevate that craft to its most strategic, high-leverage tier. Addressing lingering industry anxieties about automation eliminating developers entirely, the talk closes with a definitive defense of the discipline's future: “The software engineering role is not vanishing. It's simply evolving. And if anything, it's becoming more important.” To thrive in this new landscape, engineers must proactively shift left in the development lifecycle, shift up into higher-order architecture, and dedicate themselves to designing holistic, resilient systems rather than merely typing out individual fragments of code.

## Notable quotes > [40:41](https://www.youtube.com/watch?v=q_Jq4IgYImk&t=2441s) 10x output cannot come with 10x cognitive load, or that will burn people out. — Andrew Macvean

> [39:29](https://www.youtube.com/watch?v=q_Jq4IgYImk&t=2369s) The hard truth is, you can't mandate a T-shaped developer inside of a broken system. — Nicole Forsgren

> [01:26](https://www.youtube.com/watch?v=q_Jq4IgYImk&t=86s) Our top-performing engineers, they're more active, not less, even though they're delegating more and more work to AI. — Andrew Macvean

> [10:33](https://www.youtube.com/watch?v=q_Jq4IgYImk&t=633s) It isn’t a scientific mindset if we just randomly explore and we never capture and apply those learnings. — Nicole Forsgren

> [05:35](https://www.youtube.com/watch?v=q_Jq4IgYImk&t=335s) Our engineers are writing specification files, which, if we think about it, is really product thinking made explicit. — Nicole Forsgren

## Mentioned Google, Google for Developers, Google I/O 2026, Andrew Macvean, Nicole Forsgren, Developer Intelligence Team, DORA, DevOps Research and Assessment, Google Search, YouTube, TensorFlow, Peter Senge, W. Edwards Deming

## Video description Explore the essential skill domains—including core engineering principles and business context—needed to harness the full potential of AI, and unlock massive productivity gains in your daily workflow. Discover how AI is a powerful collaborator that can change and accelerate how you build software.

Speakers: Nicole Forsgren, Andrew Macvean

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

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

Reading summary

Drawing on Google internal telemetry and DevOps Research and Assessment (DORA) findings, Developer Intelligence leads Andrew Macvean and Nicole Forsgren argue that artificial intelligence is not replacing software engineers, but elevating the profession into an expanded T-shaped role. To thrive, developers must shift from manual code generation toward upfront intent specification, platform engineering, and multi-agent orchestration. The Productivity Paradox and Environment Design (1:26) While artificial intelligence now generates 75% of all code authored inside Google, Macvean cautions that widespread adoption does not automatically yield net productivity gains. External DORA research reveals an organizational paradox: AI tools frequently boost perceived individual developer output while simultaneously degrading team-level delivery if systemic bottlenecks are neglected. Inside Google, positive productivity emerges because elite developers avoid casual "vibe coding." Telemetry indicates that top-performing AI users spend more time active—coding, ideating, and collaborating—by acting as environment designers who establish strict architectural guardrails, automated feedback loops, and reasoning frameworks. Shifting Left on Intent and Specifications (5:35) Forsgren argues that the traditional practice of shifting left—historically applied to testing and security—must now pivot toward front-loading human intent, operational constraints, and architectural trade-offs. In an agentic workflow, the primary source of truth is migrating away from the code repository itself into structured specification files. These living documents make product reasoning explicit, guiding autonomous agents and preventing cognitive overload from unvetted prototypes. Developers increasingly act as "value translators," converting user problems into technical parameters so models optimize only high-impact paths. Verification Bottlenecks and Multi-Agent Orchestration (16:35) Because code generation is no longer the rate-limiting step, verification has become the primary bottleneck in software delivery. Macvean emphasizes the operational rule to "delegate tasks, not judgment," warning that unverified AI output rapidly compounds technical and cognitive debt. To maintain quality at scale, Google teams orchestrate decoupled, multi-agent systems—typically constrained to three to five specialized agents handling planning, coordination, and coding—while deploying automated CI/CD shepherding and review agents to triage diffs and escalate high-risk changes to senior engineers. Platform Abstractions and Expanded T-Shaped Roles (11:55) The modern T-shaped engineer must expand their horizontal breadth into adjacent engineering domains—such as telemetry, security, and deployment pipelines—as well as non-engineering business context. Macvean highlights internal Google Search workflows where product managers deploy live production experiments without writing traditional code. This level of cross-functional agency is possible only because engineers operate higher up the abstraction stack, precision engineering the underlying platform's reliability, scalability, and safety constraints. By managing tiered risk environments, Google has scaled AI-authored code without incurring a rise in production outages. Managing Cognitive Load through Systemic Leadership Shifts (40:41) Forsgren and Macvean warn that AI acts as an amplifier and a mirror, exposing systemic dysfunction such as brittle tools, siloed data, or blame cultures. Furthermore, continuous agent orchestration threatens developer burnout if tenfold output is accompanied by tenfold cognitive strain. To build sustainable systems, the speakers urge leadership to abandon legacy vanity metrics like pull request counts and accepted lines of code, protect dedicated time for "productive struggle" and architectural comprehension, and foster psychological safety through blameless postmortems. The speakers conclude that the software engineering craft is not vanishing, but evolving toward higher-altitude system design and strategic execution. However, they emphasize that individual technical upskilling cannot succeed in isolation if engineering leadership fails to provide resilient platform infrastructure, blameless operational cultures, and outcome-oriented evaluation metrics.

Source quotes

[40:41] Andrew Macvean: 10x output cannot come with 10x cognitive load, or that will burn people out. [39:29] Nicole Forsgren: The hard truth is, you can't mandate a T-shaped developer inside of a broken system. [1:26] Andrew Macvean: Our top-performing engineers, they're more active, not less, even though they're delegating more and more work to AI. [10:33] Nicole Forsgren: It isn’t a scientific mindset if we just randomly explore and we never capture and apply those learnings. [5:35] Nicole Forsgren: Our engineers are writing specification files, which, if we think about it, is really product thinking made explicit.

Original transcript

[0:00] [MUSIC PLAYING] [0:06] ANDREW MACVEAN: Hi, everyone. [0:07] How are we doing? [0:11] Here we go. [0:12] How are we feeling? [0:14] Excited? [0:16] There we go. [0:17] Maybe a little overwhelmed? [0:19] Curious? [0:21] Hopefully, curious. [0:22] OK, well, we're Andrew and Nicole. [0:24] We're both leads on the Developer Intelligence Team [0:27] here at Google. [0:28] And together, we spend our careers [0:29] studying software engineers-- the people, the processes, [0:32] the tools, the systems, the culture. [0:35] And we want to start by recognizing, [0:37] this is a big moment for software engineering. [0:41] You see quotes like this that really emphasize [0:43] not just the magnitude of the moment [0:46] but the speed at which change is happening. [0:50] Our goal today is to share some of our research, some [0:52] of our knowledge about what we're seeing inside of Google, [0:55] and ultimately answer this question. [0:57] How can we, as software engineers, [0:59] continue to thrive in the AI-native era? [1:03] We're going to do that by walking [1:05] through this T-shaped software engineering role [1:07] that we're seeing really grow in importance. [1:11] We'll go into detail on some of the patterns we're [1:13] seeing in terms of how software engineering is being done, [1:16] the skills and the capabilities we're [1:18] seeing are top engineers embody, and introduce [1:21] some practical tips for how you can think about your role. [1:26] But first, we want to set the scene. [1:28] We want to make sure we're all on the same page here. [1:30] Like we said, this is a big moment. [1:33] But what's actually happening? [1:36] First of all, we're seeing fairly pervasive adoption [1:38] of AI tools for software engineering-- [1:41] probably not a surprise to anyone here. [1:43] The majority of tech professionals [1:45] are using AI and relying on it, in many cases, a lot. [1:50] We're also seeing profound impact. [1:52] So inside of Google, 3/4 of all code is written by AI. [1:58] At the same time, people are very reasonably asking, [2:01] is it actually improving productivity? [2:04] And if it is, is it 10%, 10x, 100x? [2:09] The truth is in some places, there's [2:11] even a productivity paradox occurring. [2:13] There's some research that our DORA team [2:15] did by studying multiple companies that increasing AI [2:19] adoption can lead to individual productivity benefits, while, [2:23] at the same time, decreasing team-level benefits. [2:27] Over the last year inside of Google, [2:29] we've seen some really interesting patterns emerge. [2:32] First of all, we are seeing a lot of benefits. [2:35] Not only are we seeing AI generate [2:37] an increasing amount of code with more and more autonomy. [2:41] We're seeing that with the right system, the right environments [2:44] in place, that code actually lasts. [2:48] This presentation is about the skills and the capabilities that [2:51] really allow that to happen. [2:54] Second of all, there's some really interesting emergent [2:56] behaviors beyond those top-line numbers. [3:00] For example, we're seeing that the engineers that use [3:02] AI the most, they're actually spending more time coding, [3:06] more time ideating, and more time collaborating [3:08] with their peers. [3:10] This is maybe counterintuitive. [3:12] The truth is, they're doing more of these activities. [3:16] The shape of them just looks a little different. [3:19] Our top-performing engineers, they're more active, not less, [3:22] even though they're delegating more and more work to AI. [3:28] Now, it's important to note those AI benefits, [3:30] they're not necessarily homogeneous. [3:33] We know all about the old adage, garbage in, garbage out. [3:36] And we've seen a lot of research around the need [3:38] to not only really master working [3:40] with AI but also the context and the domain in which you're [3:43] applying that AI to. [3:47] Furthermore-- and this is likely preaching to the choir here-- [3:49] but software engineering is so much more than coding. [3:52] And coding was never actually the bottleneck. [3:56] We're talking about a hugely complex here. [3:59] To get the true benefits, we need to really recognize [4:02] two more things. [4:04] First, we need to think about AI for the entire software [4:07] development lifecycle and, indeed, the entire product [4:10] development lifecycle. [4:11] We need to think about AI way beyond code generation. [4:16] Second, this isn't just about applying AI [4:18] to the old ways of working. [4:20] The magic actually happens when those traditional processes, [4:24] they're evolved and even transformed. [4:27] We're going through multiple paradigm shifts. [4:29] We're seeing totally new processes [4:31] emerge with totally new people taking [4:33] on new roles in the software development lifecycle. [4:38] So I go back to the question that we introduced at the start. [4:41] This is a lot of change to deal with. [4:44] Well, hopefully, today, I've got two pieces of good news for you. [4:48] The first is however you are feeling, [4:51] trust me, you are not alone. [4:53] There's a lot of research on this, both inside and outside [4:56] of Google, and there's a lot of really complex emotions [4:59] emerging. [5:00] None of this is surprising given the size [5:03] and the speed of change. [5:04] The excitement is real. [5:06] The opportunities are real. [5:08] But it is a lot. [5:10] The second piece of good news is that this talk is really about [5:13] how you can rise above all of this [5:15] and continue to thrive in this AI-native era. [5:19] There are no magic wands, but there are ways to thrive. [5:22] We're seeing strong evidence that despite the new shape [5:25] of the software engineering role, when the change is [5:27] approached intentionally, this really [5:30] can and should be the most exciting time [5:32] to work in this field. [5:35] NICOLE FORSGREN: Thanks, Andrew. [5:36] OK, so let's talk a little bit about the patterns [5:39] that we're seeing in our highest-performing engineers [5:41] that are really adopting an AI-native approach. [5:44] Here we'll introduce some interesting behaviors [5:47] that we're seeing emerge. [5:48] And then we'll pull it all together [5:49] to talk about this really expanded role of software [5:51] engineering. [5:54] As Andrew mentioned, our job is to really study and measure [5:58] the engineering system and all of the pieces [6:00] that fall within that. [6:01] So we're measuring end-to-end time, [6:03] how long it takes to go from an initial seed [6:05] of an idea of the way to getting that idea out [6:07] into a real user's hands. [6:10] So here we're thinking about not just software engineering [6:13] and coding but actually the entire product development [6:15] process. [6:17] In that system, our most productive AI-native engineers, [6:21] they're doing a few things differently. [6:24] We'll go through five patterns that we're seeing emerge. [6:28] First is that these engineers are [6:30] operating at higher altitudes. [6:32] They are combining their engineering knowledge, [6:34] but they're also applying their understanding of business [6:38] context and user needs. [6:40] They're thinking deeply about why [6:41] they're building it, not just what they're building or how. [6:45] Now, if we think about this, this [6:47] has always been what's expected of senior engineers. [6:50] But now that we have AI accelerating execution, doing [6:53] it well has never been more important. [6:57] Second, they're shifting left on intent. [7:00] I know some of us have heard this at the conference today. [7:02] Now, traditionally, shifting left [7:04] meant moving testing or security earlier into the software [7:08] development lifecycle. [7:10] But today, we have more and more work being handled autonomously [7:13] by agents. [7:14] So now we need to shift left on intent. [7:17] We need to spend more time upfront and energy [7:20] to really plan, explain these clear instructions, [7:23] talk about trade-offs, provide the right context. [7:27] What this means is that a fundamental source of truth [7:30] is moving away from the code itself. [7:33] And it's really shifting toward the structured intent [7:35] that happens upfront. [7:36] Our engineers are writing specification files, [7:39] which, if we think about it, is really [7:40] product thinking made explicit. [7:43] This helps better guide our AI, but it also [7:46] documents the decisions much more explicitly than some of us [7:49] have done in the past. [7:51] And this is critical because as agents [7:53] are taking on more and more execution, [7:54] they need to know these trade-offs and these decisions [7:57] as they're building. [7:58] I know that building without capturing intent [8:01] is really tempting-- it's fun to do on a weekend, maybe. [8:04] But we risk having prototypes that no one understands [8:08] the rationale for. [8:09] So when we actively organize this continuously evolving [8:13] knowledge, that's one strong strategy [8:15] to prevent severe cognitive overload. [8:20] Building on the point before that I just made, [8:23] our top engineers are not vibe coding. [8:25] They're not just prompting for code. [8:27] What they're doing is they're designing environments. [8:30] They're setting guardrails. [8:31] They're creating systems so that agents and humans [8:34] can work together toward a goal and a broader purpose. [8:38] Think of this like creating a system of reasoning [8:40] so that we can operate at scale beyond what one person can do. [8:45] So this also includes now setting up [8:47] agents, teams of agents, giving them the right context, [8:49] giving them the right skills to be able to act. [8:52] Our top engineers-- I know someone else [8:54] mentioned this in another session. [8:56] They don't just want fast code. [8:57] They want verified, high-quality code. [9:00] So when we delegate to these teams of agents [9:02] and we're delegating this execution, [9:05] how do we keep the bar high? [9:06] How do agents know when to act and even where [9:09] to debate each other to find better solutions? [9:12] So this all comes from the second pattern [9:14] and the specifications and intent files [9:16] that we just discussed. [9:17] And even though we're shifting left on intent [9:20] and capturing this and specifying it early, [9:22] feedback loops are really important to this process. [9:28] Next up, AI isn't just changing the way that people build [9:31] but who can build it. [9:33] It's really decoupling a person's job role [9:36] from the types of things that they can do in the tasks [9:38] they perform. [9:40] We're also seeing the rise of a micro-team, small [9:43] cross-functional agile pods. [9:45] These have less communication overhead and much [9:47] tighter collaboration loops. [9:49] These teams can execute at really large scale [9:53] and good velocity thanks to the agents [9:55] that they're using and deploying. [9:56] But again, this is only possible if we shift left on intent [10:00] because that helps us master the delegation to agents. [10:04] We have to clearly articulate the context, the constraints, [10:06] the goals, the trade-offs, the success criteria [10:10] so that the agents can handle how and not repeat mistakes [10:14] or keep iterating and creating things [10:17] they've already learned about. [10:19] So we also need to design the system [10:20] so our agents can access the right tools, [10:22] navigate data, and then iterate with you moving forward. [10:27] The fifth and final pattern is really [10:28] about having a scientific mindset and how we all [10:31] need to continually explore. [10:33] If we're going to work at the cutting edge, [10:35] we need to be open to failure. [10:37] Things are moving so fast it's rarely right [10:40] about-- the idea's rarely about getting it right the first time. [10:43] It's to learn what we can as we move and then [10:47] iterate and contribute up into a learning organization. [10:52] Now, every week, our engineers are [10:53] experimenting with new approaches [10:55] and investing in codifying that learning back into the system. [10:58] Again, intent and feedback loops here are key. [11:01] It isn't a scientific mindset if we just randomly explore [11:04] and we never capture and apply those learnings. [11:08] So pulling this all together, we're [11:09] talking about shifting left, shifting up, and system design. [11:14] Now, system design includes the environment, [11:16] the actors in that environment, humans, agents, and tools, [11:20] and of course, the culture that ties it all together. [11:22] This lets us focus our efforts on the most important problems [11:25] to really learn and adapt as quickly as possible [11:28] and then execute effectively while feeding insights back [11:31] into the system. [11:33] OK, so we just talked through five patterns [11:35] that we're seeing during this shift. [11:37] And if we go back to the goal for today, [11:39] we want to put that together into a way of thinking [11:41] about the core skills that we need to really thrive [11:44] in this AI-native era. [11:45] We will repeat ourselves a few times. [11:48] But we really want to help connect the dots [11:50] and emphasize some of the things that we're [11:52] seeing in this evolution. [11:55] As we mentioned, our top performers [11:57] are increasingly T-shaped, and the idea of a T-shaped developer [12:01] isn't new. [12:01] We've heard of this before. [12:03] Yeah, we're quite familiar with it. [12:05] We are seeing a few things emerge, though. [12:07] Now, for those who haven't heard of a T-shaped engineer, [12:10] the basic premise is that this top bar, the horizontal bar [12:13] of the T, represents a broad foundation of knowledge [12:16] in the wider, software engineering ecosystem. [12:19] It doesn't mean we have expertise in all areas, [12:21] but we have a good understanding of how key parts of the system [12:24] work. [12:26] And then, the vertical stem of the T [12:28] represents the deep, specialized knowledge and hands-on expertise [12:31] that a software engineer has. [12:33] It can be within a specific field, like fintech. [12:35] It can be on a particular technology stack or framework. [12:38] But that's our deep expertise. [12:41] What we're seeing, though, is an interesting evolution [12:44] of this T-shape. [12:45] First, there's a new layer of horizontal expertise [12:48] that we need. [12:49] And that is really about effectively working [12:52] with and engaging with AI. [12:55] It's non-negotiable that AI-native engineers can really [12:58] understand the constraints of AI in a task-specific context. [13:02] We need to be able to assess the outputs and the quality [13:05] and ultimately steer AI effectively. [13:09] We're also seeing some additions on the wings of the T here. [13:14] We're seeing some more breadth required. [13:17] Because AI has this lower barrier to entry, [13:19] and it's really increased the throughput of coding, [13:22] it's more important than ever to understand this context. [13:25] So on one arm, we have adjacent engineering. [13:28] Because AI is creating more and more functional code, [13:33] the key considerations and trade-offs that we're making [13:36] need to be at the forefront of what we're thinking about here. [13:40] The second area here is adjacent non-engineering. [13:44] And specifically, this is about business and user context. [13:48] Because now AI can handle how of coding, [13:51] we need to make sure that we are thinking about and understanding [13:54] the business and contextual needs that we're solving for. [13:59] I think one thing that's interesting [14:00] is that this is already what's expected [14:02] of our senior developers. [14:04] We've talked about this a little bit. [14:05] But now that our engineers are working [14:07] at higher and higher altitudes, we can do more with agents. [14:13] So the difference here is really that, A, [14:15] there's a fundamental assumption about using AI effectively. [14:19] And B, for a lot of the reasons that we discussed, [14:22] AI makes the depth and breadth needs a little more acute. [14:25] We notice them a little bit more. [14:27] We need that adjacent knowledge. [14:29] We need the depth of technical knowledge. [14:31] Otherwise, AI can just make us do wrong things faster. [14:36] ANDREW MACVEAN: Awesome. [14:37] Thank you, Nicole. [14:38] With us so far? [14:40] So far, so good? [14:41] OK, we're going to unpack the model a little more. [14:44] We're going to move through each of the T-shaped skill domains. [14:47] And for each, we'll give you a few stories, a few anecdotes [14:50] from inside of Google. [14:52] We want to really emphasize a few things. [14:54] First of all, how things are actually playing out today, [14:57] what we're learning, and really make clear the importance [14:59] of the entire T shape. [15:01] We'll then pull it together by sharing [15:03] some of those practical tips we mentioned that really help [15:05] you acquire or embody the behaviors and the recommended [15:09] practices. [15:12] OK, let's start with core software engineering skills. [15:14] And to understand how these skills are evolving, [15:16] I want to share a story from our search organization. [15:20] Right now, we have product managers [15:22] who are shipping features all the way through [15:24] to live experiments. [15:26] Now, they aren't writing traditional code. [15:28] They're using some of our internal platforms that help [15:31] translate their intent-- that's the user or the business need-- [15:34] into working features on our real production tech stack. [15:39] Now, from the outside, you could think, hey, [15:41] if PMs are coding their way to production, [15:44] what role do those traditional core software engineering skills [15:47] actually play? [15:49] The reality is, none of this is possible without an incredibly [15:53] advanced platform. [15:55] The deep expertise in system architectures, [15:57] the different strands of different language frameworks, [16:00] they're all baked into the platform, [16:03] as are the scalability requirements, [16:05] the reliability requirements, et cetera. [16:08] Now, this to me, this is a really nice example [16:10] of how the engineer is working higher and higher [16:12] up the abstraction stack. [16:14] The engineer isn't handcrafting those individual features. [16:17] They're precision engineering the ecosystem that allows [16:20] those features to exist safely. [16:23] Now, that requires more engineering depth, not less. [16:28] So given this general trajectory, [16:30] let's talk about three concrete shifts [16:32] we're seeing around these skills. [16:35] First, because code generation is happening [16:37] faster and faster, effective verification, [16:40] it can become the bottleneck. [16:42] AI can act as a massive force multiplier, [16:45] but you must possess the deep expertise [16:47] required to evaluate, integrate, and maintain its output. [16:52] However, given the scale at which AI can operate, [16:55] this is not necessarily about manually verifying each line [16:59] by line. [17:00] This isn't possible cognitively. [17:02] It's about setting those effective feedback loops, [17:05] ensuring that you catch issues reliably [17:08] and in low-stakes environments, and using [17:11] that data to ensure that you, as an engineer, [17:14] your attention gets put on the highest [17:16] value, most necessary things. [17:18] And so our internal platforms, they're [17:20] really designed to allow us to quickly test out [17:22] features, gather that performance data in a safe way, [17:26] and use these feedback loops to really target engineers [17:29] where their expertise is most required. [17:33] That's where they're then brought into the loop. [17:36] Now, this leads us to our second point. [17:38] And Nicole mentioned this already. [17:40] Our engineers, they don't vibe code. [17:42] They control. [17:44] They're really precision engineering. [17:46] If you lack deep engineering understanding, [17:48] if you don't understand the systems you're building against, [17:52] AI can run the risk of generating [17:54] technical and cognitive debt at an incredibly fast rate. [17:58] This is why our teams, they've been working [18:00] on these internal platforms. [18:01] They make development go from intent [18:04] to functioning, high-quality, reliable, and secure code. [18:09] Our engineers, they're thinking about setting [18:11] the boundaries and the guardrails of the system. [18:14] So, for example, they're specifying the nuanced style [18:17] guide conventions that the agents must adhere to [18:20] with the right checks and balances to detect [18:22] when the agents start to drift. [18:26] Now we know some of these models, [18:28] they have a tendency to sound incredibly confident. [18:31] We know that, when they're operating at scale, [18:33] it can be all too easy to just accept changes wholesale. [18:37] There's a saying I like-- [18:38] delegate tasks, not judgment. [18:41] It's essential that it's your core engineering [18:43] skills that are what push the model in the right direction. [18:47] Again, this is about creating the environment-- [18:50] the system where issues can be caught and remediated [18:53] with minimal risk. [18:55] What we don't want is intellectual passivity. [18:57] That's why the feedback loops are so important here. [19:00] It's about getting end-user feedback, performance feedback, [19:04] and using that to measure adherence to the intent. [19:07] Observability is critical so that we [19:10] can establish where guardrails may be missing, [19:12] or agents are making incorrect assumptions because they [19:14] don't have the right context. [19:18] OK, so it's easy to stand up here [19:20] and say, maintain your deep expertise. [19:22] But how do you actually do that in this fast-moving, [19:24] ever-changing environment? [19:26] Here's three practical tips that our top teams are really [19:29] embracing. [19:31] First, we really recommend re-implementation [19:34] as a learning tool. [19:35] Because AI can generate solutions so quickly, [19:38] don't just accept the first draft. [19:40] Instruct the AI to tear it down and re-implement it. [19:44] Ask it to document its logic for why it approached it differently [19:47] and what it learned in the process. [19:49] This is incredibly useful for checking [19:51] those initial assumptions, seeing where context [19:54] may be missing, and thinking through the implications [19:57] of different approaches. [20:00] Second, we encourage our teams to do walkthroughs [20:03] of alien code, system architectures, and agent [20:07] decision traces. [20:08] We have engineers explain the code or the systems [20:11] that they did not write themselves in order [20:13] to help build the shared mental model and the theory [20:16] of the system we know to be so important. [20:19] Now, analog approaches, they work incredibly well here. [20:22] And so we've actually seen teams adopt [20:24] more and more whiteboarding to help articulate [20:27] that logic in the system. [20:30] For us, code is increasingly not the first-class outcome. [20:34] It's adherence to that intent, your ability [20:37] to hit those business and end-user goals, [20:39] and a shared understanding of the system [20:42] which should be a deliberate deliverable. [20:46] Third, I'm sure you've all seen the increasing practice of using [20:50] skill files, rule files, et cetera to really explicitly [20:54] codify team practices, expectations, [20:57] and institutional knowledge into your agents [21:00] in a consistent and scalable way. [21:02] And this is something we've seen become increasingly important. [21:05] We're talking about ways to context engineer [21:08] at scale with greater reliability. [21:11] Our best teams, they don't just use agents out of the box. [21:15] They're creating, they're curating, [21:17] and they're maintaining structured agent role profiles, [21:21] giving them very specific behavioral attributes [21:24] and providing them with the recipes [21:25] to effectively work inside our system. [21:28] Again, being forced to consistently reflect [21:31] on what good looks like-- what is [21:32] a good behavior from an agent? [21:34] That's a really good way to remain sharp [21:36] in your core engineering skills. [21:38] It ensures you have an up-to-date understanding [21:40] of the system you're trying to build, [21:42] and that you're creating those feedback [21:43] loops to know what is working, what's not, [21:46] and how to make your agents more effective. [21:49] Now, importantly, these skills, the rules, the system specs, [21:52] they should be treated like you would other [21:54] code, with appropriate version control and observability [21:57] practices in place. [22:01] NICOLE FORSGREN: Thank you. [22:02] OK, next, we'll talk about GenAI use. [22:05] We want to share a little bit more [22:06] about how our engineers are working with AI [22:08] and how they're building the right systems so [22:10] that their AI can be effective. [22:13] Here, we're really moving beyond an era of AI enhancement [22:16] to AI-native engineering. [22:18] This is a big mental model shift from being [22:20] a conductor of a single agent to really an orchestrator [22:23] of an entire system. [22:27] So here, we're seeing three principles emerging. [22:30] Our orchestrators are managing teams of asynchronous AI agents. [22:35] Each has its own context window. [22:37] Each has its own specific area of responsibility. [22:40] And then, the human software engineer [22:42] above is the one who sets the environment [22:43] and directs the flow. [22:45] Our engineers are directly and indirectly [22:47] teaching agents how to act by giving them [22:49] the skills that Andrew mentioned, [22:51] which is essentially giving them the exact recipes [22:54] and tools and domain knowledge that they [22:56] need to execute their tasks. [22:59] This shift to orchestration is a new skill. [23:03] We need to know when to delegate and when not to delegate. [23:06] Our top teams really help avoid this automation trap [23:09] by establishing clear human baselines for their work [23:12] and measuring the verification overheads. [23:15] To help climb to a win, we run experiments, [23:17] and we find the tasks where the probability of success [23:20] is the highest. [23:21] This allows us to keep human attention on the tasks [23:24] that we know agents can't yet perform [23:26] or where taste and judgment is really essential. [23:31] Because evaluation cost is a new critical bottleneck, [23:34] our engineers are having to deeply engage with their system [23:37] thinking skills. [23:38] Where we don't see enough success, [23:40] we start analyzing agent traces and we [23:42] build a shared understanding of where our system can improve, [23:44] whether it's something like the usability of tools [23:47] that the agents aren't using or the skills [23:49] that agents themselves have been equipped with. [23:52] One example is adversarial review agents. [23:55] Here we're seeing engineers deploy these [23:56] to push at decisions and push at their edge cases. [23:59] Traces are documented, and the intent and agent rules [24:02] are then updated because we learn from what we've done. [24:05] None of this is possible without a deep understanding [24:08] of the underlying software systems, while also having [24:10] the AI skills that understand the strengths [24:13] and weaknesses of the model and of the agents [24:15] that we're working with. [24:17] Inside of Google, we're seeing substantial growth [24:20] in the amount of code that needs reviewed. [24:22] And so we're building code review agents. [24:25] Their goal is to evaluate functionality, reliability, [24:28] performance, usability, security, and even [24:31] maintainability. [24:32] Our goal is not to replace human code reviewers with AI [24:35] but, rather, create tighter and tighter feedback loops. [24:38] We want to catch as many issues as we can as early as possible. [24:42] We want to feed those issues back into the system, [24:44] for example, documenting where incorrect assumptions were made, [24:47] all while preserving human cognition [24:50] for these high-value tasks. [24:52] So that's why we started creating shepherding agents. [24:56] These agents guide changes through our CI/CD pipelines. [24:59] They trigger review agents multiple times. [25:01] And then, they also leverage risk assessor agents [25:04] that scan in-flight changes and flag high-risk changes [25:08] for human review. [25:10] Of course, I come back to the need for software engineers [25:13] to delegate tasks, not judgment. [25:15] I think we share that as a favorite quote. [25:18] Our software engineers are playing a critical role here. [25:21] First, they help define expectations [25:23] around topics like usability and maintainability. [25:26] What do we even mean by these things? [25:28] How does it differ team by team? [25:30] How is it contextually specific? [25:32] Second, there tend to be trade-offs [25:34] between these constructs. [25:36] In which situation do we prioritize performance, [25:38] or do we prioritize usability? [25:41] Applying this requires human judgment and taste. [25:44] AI can help inform us. [25:45] It can help surface the risks in the trade [25:47] that we're considering. [25:48] But ultimately, the judgment comes from the human. [25:52] So how can we upskill ourselves to work more effectively [25:55] with agents? [25:57] And maybe more importantly, how can you [25:58] help your organizations and your systems [26:01] be ready to embrace these new ways of working? [26:04] First, we strongly recommend upskilling on evals. [26:07] Because verification is such a big bottleneck, [26:10] you need to be confident in how you evaluate AI output. [26:14] The whole of the T-shaped engineer [26:15] is essential here because it really [26:17] requires a mix of AI, software engineering, user and business [26:21] skills to make sure that we're developing realistic, grounded, [26:24] and relevant evals. [26:26] Our evals are also a critical artifact [26:28] to ensure shared team knowledge, and they're a big part [26:31] of how intent is captured. [26:33] They help us define what good looks like. [26:36] Second, our top engineers are not just [26:38] doing personal self-reflection, but they're [26:40] forcing their agents to constantly reflect and document. [26:44] We think about this a little bit like agent journaling. [26:46] It is fascinating, at the end of the day, [26:49] to see how my agent perceived its day-- [26:52] where it got stuck in the system, [26:53] where it got confused about instructions, [26:55] where it felt productive. [26:57] These reflection journals give me insights and give all of us [27:00] insights into how we can improve, not just how [27:02] we work with AI, for example, giving it [27:05] clear instructions on what language or framework to use. [27:08] But also, we can improve the entire ecosystem [27:10] around the agents. [27:11] For example, if your agent is consistently having difficulty [27:14] accessing an internal tool, you might have a tool usability [27:17] problem that's worth solving. [27:20] Third-- and I know we've said this a couple times already-- we [27:24] want to build teams of agents. [27:26] Now is the time to really lean into the opportunity [27:29] to scale beyond a single agent to a balanced team [27:32] with strict rules and protocols. [27:35] We're doing this right now inside of Google, [27:37] for example, with some migrations we've [27:39] been doing around TensorFlow. [27:41] This is highly complex, delicate work. [27:43] Instead of using a single chatbot, [27:46] our team deployed a strict three-agent architecture-- [27:49] one, a planner agent that generates verifiable migration [27:53] steps; two, an orchestrator agent that groups those steps; [27:57] and then, finally a coder agent that executes them. [28:02] Our top-performing teams scale beyond single agents [28:05] by codifying their best practices, for example, [28:07] around stylistic rules and coding preferences. [28:10] In the TensorFlow migration example, [28:12] different playbooks are fed into the agents [28:14] to ensure a migration in one product area, [28:16] like YouTube uses YouTube-specific practices. [28:20] Another thing to consider here is agent sprawl. [28:22] For example, some argue you should [28:24] stick to three to five agents so you can meaningfully [28:26] track the work. [28:28] I think we're generally aligned with this as a sweet spot. [28:31] But we are seeing more and more tools [28:32] emerging to support multi-agent system [28:35] management with an increasing number of agents. [28:37] And we think some of the techniques we've discussed here [28:39] can help you with that additional scale. [28:43] This leads to our final point. [28:46] We can't rely on vague prompts and expect [28:48] high-quality outcomes. [28:50] We need precision engineering. [28:52] Here is where we're seeing spec-driven development, where [28:55] product thinking and architectural decision-making [28:58] are showing up, and they're being documented upfront, [29:01] and they're increasingly important. [29:03] Goals, constraints, rationale-- these are critical contexts, [29:07] not just for the agents executing the tasks, [29:09] but really for the broader team. [29:11] The specs, when we combine them with agent roles and skills, [29:14] are a source of truth for what and the why of the system [29:17] that you're building. [29:19] Here they're documented to guide agents [29:21] at scale that support system understanding [29:23] and maintainability. [29:26] ANDREW MACVEAN: All right. [29:27] So we've really implicitly talked [29:28] about the agent-adjacent skills a few times [29:31] already because, really, all of these capabilities, [29:34] they're interacting with each other all the time. [29:36] Take the review agent as a clear example of combining all four. [29:40] But let's now move to the adjacent engineering wing. [29:43] And this is where domains like cybersecurity, privacy, [29:46] and industry-specific regulations, [29:48] as well as deployment infrastructure, [29:50] become so important. [29:53] If your organization has high-quality internal platforms, [29:56] strong APIs, clear, well-documented workflows, [30:00] AI really acts as a powerful collaborator. [30:03] But if you suffer from fragmented tooling, siloed data, [30:06] and maybe fragile infrastructure, [30:09] AI is maybe not going to save you. [30:11] It'll simply help you generate technical debt faster. [30:14] There's some wonderful research that our DORA team [30:16] did that really speaks to this point. [30:19] AI is an amplifier, and it is a mirror. [30:21] It magnifies those existing strands while it holds up [30:25] a mirror to those weaknesses. [30:28] The adjacent engineering wing, this [30:29] is where AI is most likely to introduce quiet, catastrophic [30:33] debt if it's left unchecked. [30:36] And so let's talk about three principles [30:37] to help mitigate this. [30:39] First of all, our story of the search PMs, [30:41] it's highly relevant here too. [30:43] Embedding those best practices directly [30:46] into a high-quality internal platform, [30:48] that's what allowed us to get those features out [30:50] without handcrafting each line of code. [30:53] That requires many, many adjacent engineering [30:55] skills, for example, understanding the deployment [30:58] environments, the security needs, reliability needs, [31:01] as well as those deep core engineering skills [31:03] that we've already discussed. [31:06] One of the statistics we're most proud of [31:08] is that while we are seeing increases [31:10] in the amount of code being written by AI, [31:12] we have not seen any measurable increase in outages or decrease [31:16] in system reliability. [31:18] What we want is 10x the velocity without 10x the risk. [31:24] One way that we've achieved this is [31:25] by creating tiered risk environments. [31:28] We recognize that different applications, [31:30] they have different environmental needs. [31:33] For example, an internal Google application [31:35] doesn't need to scale to a billion users. [31:38] So our goal is to get from a prototype [31:40] all the way to production in a more incremental and iterative [31:43] fashion. [31:44] We're moving through these different risk profiles [31:47] and, in the process, really containing the blast [31:50] radius while still achieving faster and faster feedback [31:53] loops. [31:55] This also speaks to other adjacent engineering skills, [31:58] like effective experimentation. [32:00] When features are moving through your system faster and faster, [32:03] how do you actually get them out to users [32:05] in a way that isolates the features appropriately [32:08] and allows you to measurably understand [32:10] how they're performing? [32:12] Thinking through these environments, [32:14] the critical architectural and deployment considerations, [32:18] this is becoming increasingly important for our engineers [32:20] to engage with. [32:23] So how do you actually build these muscles? [32:25] Here's four tips we're seeing our top teams embrace. [32:29] First, we highly encourage a culture [32:32] of blame-free postmortems. [32:33] To build truly resilient systems, [32:35] you need to make a habit of documenting, reading, [32:38] and, importantly, discussing outages and incidents. [32:41] This really builds your intuition [32:43] for those edge cases, scale limitations, [32:45] and the reliability threats. [32:47] It's also invaluable context as you think about how [32:50] to steer and guide your agents. [32:52] So for example, triangulating these postmortem documents [32:55] with an agent's self-reflections that Nicole discussed [32:57] and observability traces, that allows you to see where the edge [33:01] cases may be getting exposed or your system [33:03] instructions may be unclear. [33:06] Second, don't just use AI to build. [33:09] Use it to stress-test. [33:11] So going back to our points about balanced agent rules, [33:13] explicitly setting up red team agents [33:15] allows you to see your system through the eyes [33:18] of malicious actors. [33:20] Having your agents explain how they would exploit the system, [33:23] that forces you to engage with those exploit mechanisms. [33:26] Rather than just passively accepting solutions, [33:29] you begin training yourself and your agents [33:31] to spot the vulnerabilities that your generation agents may [33:34] be missing. [33:37] Now we covered this already is the really interesting rise [33:39] of analog approaches to map systems and of course, data maps [33:43] too. [33:44] Whiteboards really are at a premium, [33:46] with the real focus on thinking through [33:48] those initial architectures. [33:50] By manually tracing a pipeline, you [33:52] can build mental models of things [33:53] like enterprise compliance before a single line of code [33:56] is actually written. [33:58] Codifying that intent on a whiteboard [34:00] is a great way to challenge those initial assumptions [34:03] and ensure that your agents have the right context going [34:06] into execution. [34:08] Finally, observability really is a critical piece of the puzzle. [34:11] If features are hopefully moving through your system at 10 times [34:14] the speed, you need to be able to monitor [34:16] those to understand how things are actually [34:18] behaving in the wild. [34:20] We found, for example, that some of our earlier-career engineers, [34:23] they were getting blocked by opaque performance [34:26] metrics, really subtle system health regressions. [34:29] They didn't know how to diagnose the complex distributed systems [34:32] that they were deploying to. [34:34] And so what we did is we invested [34:35] more in observability tools and unified data agents. [34:38] And the data agents, they had access to code, [34:40] error logs, performance data stack traces. [34:44] And what we found is that we were [34:45] able to empower those engineers to better [34:47] interpret and understand the complicated systems. [34:50] This, to me, is another nice example [34:52] of not just using AI to build but using AI to understand. [34:57] OK, this brings us to the last capability in our T, [35:00] and that's adjacent non-engineering skills. [35:02] This is all about deeper alignment with user and business [35:05] needs. [35:06] Now the agents are able to handle [35:07] a lot more of the routine task execution, our engineers, [35:11] they have the mandate to focus more heavily [35:12] on what and the why. [35:15] But we acknowledge for many of us, [35:16] this is an uncomfortable shift. [35:18] Our DORA research highlighted that many developers were [35:21] facing a real identity threat. [35:23] Because we've historically derived so much value [35:26] from the sheer craft of coding, we [35:28] need to really deliberately shift how we think about [35:30] and measure our worth. [35:32] We have to lean into the broader value of our work. [35:35] That comes from solving real human and real business [35:38] problems. [35:40] Our engineers, they're increasingly [35:41] acting as value translators. [35:43] They're taking those user needs, the business needs, [35:45] and they're turning them into precise requirements. [35:48] Consider a feature request to improve performance. [35:50] And AI might be able to find and refactor an inefficient loop. [35:53] But a value translator, they first ask, [35:56] improved performance for whom and under what conditions? [35:59] They might look at metrics and user feedback [36:01] and find this specific user segment [36:04] that requires the change. [36:05] They then guide the AI to optimize the critical code [36:08] paths that actually affect that specific scenario. [36:11] Here's another example of where human taste and judgment [36:14] are really essential to point the AI resources [36:16] in the right direction. [36:20] I really like this quote from Peter Senge. [36:22] "The most effective people are those who can hold their vision [36:25] while remaining committed to seeing current reality clearly." [36:29] This perfectly captures what we're [36:30] talking about with the T-shaped engineer. [36:33] They have the ability to form that broad vision, thanks [36:36] to these adjacent skills, but also intimately understand [36:39] the technical reality, thanks to that engineering depth. [36:42] They use the systems and the practices [36:44] that we've talked about today to capture intent, maintain [36:48] understanding, and ensure we never lose [36:50] that context of the current reality as we build. [36:55] Now, of course, we're here today to talk [36:56] about the T-shaped engineer. [36:58] But software engineering isn't the only discipline [37:00] becoming more T-shaped. [37:02] We're seeing the exact same evolution [37:04] in our product managers, our data scientists, and our UXers. [37:08] We shared the story earlier about our search PMs. [37:10] Now, while it's the software engineers that [37:12] built the safe, reliable platform, of course, the PMs, [37:15] they too are extending their adjacent skills. [37:18] They're not waiting on a designer [37:20] to hand over a static [? mock. ?] [37:21] They're going from an idea of the way to a working system. [37:24] This allows us to create more nimble and more fluid teams. [37:28] Now each discipline, they still have their specific strengths [37:31] and role to play, but the boundaries are starting to blur. [37:36] For example, in one of the internal tools I work on, [37:39] PM, UX, and engineer, they're all shipping code. [37:43] Now the big problems, they're still [37:45] working on together, but something like a UI papercut [37:48] that maybe sticks out more to a designer. [37:50] That designer is just going ahead and fixing and shipping [37:53] the code themselves. [37:54] And that, to me, is the true power of this T-shaped era. [37:58] OK, we could spend a whole hour on this topic, [38:01] but here's two quick tips we're seeing teams embrace. [38:04] First, avoid the temptation to have AI synthesize [38:07] all of your user feedback. [38:09] It's incredibly tempting to just dump hundreds of user feedback [38:12] logs into an LLM and ask for a summary. [38:15] I think, if done properly, there can be space for this. [38:18] But much like we're seeing an increase [38:19] in analog whiteboard sessions, we're [38:21] also seeing an increase in traditional high-touch user [38:24] feedback sessions, and our engineers are really [38:27] enjoying being deeply involved. [38:29] Hearing the actual joy or the actual frustration in a user's [38:33] voice, it builds profound empathy, [38:35] and it really makes the why behind things more real. [38:40] Second-- and we've mentioned this a few times-- is [38:42] spec-driven development. [38:43] Really treat your spec as the ultimate product deliverable. [38:47] Our best teams, they are fiercely [38:49] protective of these specifications. [38:51] A lot of their cognitive energy goes [38:53] into debating the goals, the business logic, [38:56] and the edge-case constraints. [38:58] Forcing this clear articulation early and in the open [39:01] has really ensured teams get aligned on the why [39:04] and helped agents have access to the more nuanced [39:07] institutional knowledge. [39:08] Remember when everyone can prototype at lightspeed, taking [39:12] a few moments to capture intent really [39:14] prevents exploration from just turning into chaos. [39:18] And because we treat these specs like code, tools like the review [39:21] agent that we mentioned, they can really [39:22] be used to stress test requirements [39:24] or look for logical collisions before the execution has begun. [39:29] NICOLE FORSGREN: OK, now we're going to pull it all together. [39:33] When we combine the deep expertise [39:35] that we need to catch AI's mistakes, the skills [39:37] that we need to orchestrate the fleet, [39:39] we have our adjacent engineering so that we can understand [39:43] the system, and our non-engineering [39:45] to really give us that broader context. [39:47] That's what we're seeing it takes [39:48] to thrive in an AI-native era. [39:50] Here, we're talking about possessing the skills to capture [39:53] and translate knowledge in a way that preserves [39:55] signal-to-noise for both humans and agents [39:58] so that we can have that virtuous improvement system. [40:01] Hopefully, the framework and capabilities and patterns [40:03] that we've shared give you a useful way [40:05] to think about your role or give some inspiration for things [40:08] that you can try. [40:10] We also want to talk a few minutes [40:12] to speak to the engineering managers and leaders [40:14] in the room. [40:15] Engineers do not work outside of an org, and we don't work alone. [40:20] So that's what we focused on so far. [40:22] But the hard truth is, you can't mandate a T-shaped developer [40:26] inside of a broken system. [40:29] As our DORA research shows, and as Andrew mentioned, [40:32] AI can be a harsh mirror reflecting all of our weaknesses [40:37] as well as our strengths. [40:38] If we have well-aligned teams with strong practices, [40:41] AI can accelerate value delivery. [40:43] But if you have fragmented tooling, siloed data, [40:46] or especially a culture of blame, AI won't save you. [40:49] It is simply going to expose all of those bottlenecks. [40:53] I love this quote from Deming. [40:55] "A bad system will beat a good person every time." [40:59] Right now, we're asking engineers [41:00] to really focus their attention on some of the hardest [41:03] architectural decisions. [41:05] We're asking them to verify machine output [41:07] and then context switch all the time between multiple agents. [41:11] This can really be cognitively exhausting. [41:13] 10x output cannot come with 10x cognitive load, [41:17] or that will burn people out. [41:19] So as a leader, how can we create an environment [41:22] where our engineers can safely evolve, [41:24] so that our engineers can embrace the expanding [41:26] T-shaped role? [41:28] We recommend three immediate shifts. [41:31] First, redefine how you measure productivity. [41:35] We have to stop measuring our teams [41:36] by pull requests, throughput, or lines of code accepted. [41:40] We should reward outcomes and business needs that are met. [41:43] We need to focus on the right outcomes [41:45] with a balanced understanding of value. [41:48] For example, if we measure only speed and never quality, [41:51] our developers won't take time to rigorously verify [41:54] AI's output. [41:55] And then system instability skyrockets. [41:57] We recommend a balanced portfolio of metrics. [41:59] And there are a lot of good resources [42:01] out there to get you started. [42:03] Second, actively protect this productive struggle. [42:07] We have to carve out dedicated time during work hours [42:10] so that our devs can learn these tools [42:12] and understand the systems that they're building. [42:14] Encourage them to manually do architectural walkthroughs [42:17] or experiment with a new tool or approach [42:20] so that they can learn how tools handle [42:23] different problems differently. [42:25] If you don't give them the space to build [42:27] these important mental models, your team [42:29] will just drown in cognitive debt. [42:32] Third, foster radical psychological safety. [42:36] We're in an era of experimentation. [42:39] Your teams are going to build agentic workflows that fail. [42:42] If your culture punishes those failures, [42:45] developers are going to rely on the skills that they have [42:48] and their old, safe ways of working. [42:50] We need to celebrate intelligent failure, [42:53] create blameless postmortems, so that the whole team learns [42:57] from the mistakes that are happening in the system. [42:59] Now, all of this has always been true, but we've said all along, [43:03] AI is really a mirror and an amplifier. [43:07] We want to conclude by explicitly acknowledging [43:10] and re-emphasizing just a few things. [43:14] Managing an agent workforce while architecting [43:16] complex systems could sound exhausting [43:19] because it forces us to stay exclusively [43:21] in this high-altitude decision space. [43:23] The silver lining is that while the nature of our effort [43:25] is changing, we still have that joy of building. [43:30] By investing in the expanded T-shaped developer skill set, [43:33] you get to see your ideas come to life at unprecedented speeds, [43:37] and they bring you closer to the actual software that you [43:39] want to create. [43:41] You aren't leaving behind the craft of software engineering. [43:43] You're simply stepping up to its highest and most [43:45] impactful level. [43:47] And most importantly-- I know we've said this, [43:49] but it's worth reiterating. [43:50] The software engineering role is not vanishing. [43:52] It's simply evolving. [43:53] And if anything, it's becoming more important. [43:57] So we need to shift left. [43:58] We need to shift up. [44:00] And we need to think about designing systems, not just [44:04] bits of code. [44:06] So thank you. [44:07] [MUSIC PLAYING]