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)