Google's Forsgren Warns AI Coding Surges Clog Software Delivery

Nicole Forsgren: Leading high-performing engineering teams in the age of AI - The Pragmatic Summit — The Pragmatic Engineer

The Pragmatic Engineer

Accelerating code generation with AI chokes delivery pipelines and exhausts developers unless organizations overhaul manual review bottlenecks and instrument outer-loop systems.

AI-assisted summary of Nicole Forsgren: Leading high-performing engineering teams in the age of AI - The Pragmatic Summit — original source. Check the original for full context.

Source published:

Key ideas

  • Accelerating code generation through generative AI has intensified bottlenecks in the delivery outer loop, causing major backlogs in code reviews, releases, and security compliance. (1:39)
  • Instant feedback loops from autonomous AI agents paradoxically increase cognitive exhaustion, forcing engineers to rebuild their mental models dozens of times within 30-minute intervals. (9:09)
  • Autonomous self-healing AI agents cannot operate effectively without lightweight, end-to-end system observability, as agents lack the informal human intuition and tribal knowledge needed to navigate fragmented architectures. (28:31)
  • Measuring AI tooling ROI through raw activity metrics like lines of code or pull requests congests pipelines; evaluation requires multidimensional frameworks such as SPACE combined with voluntary adoption signals. (17:53)

Detailed notes

## Background Published on YouTube on March 22, 2026, by The Pragmatic Engineer, this session from The Pragmatic Summit features Nicole Forsgren, co-author of Accelerate and author of Frictionless. The talk and interview explore leading high-performing engineering teams during the rise of AI, diagnosing organizational friction, and navigating developer productivity beyond superficial metrics.

## TL;DR Forsgren outlines the growing bottleneck paradox in modern software delivery: generative AI tools dramatically accelerate inner-loop code generation, but outer-loop phases like manual reviews, security checks, and releases are overwhelmed by the sudden influx of code. She examines the cognitive toll of rapid agent feedback, noting that near-instant responses often disrupt deep focus and force developers to continually rebuild mental models. To evaluate AI impact accurately without relying on vanity output metrics, Forsgren advocates using multidimensional approaches like the SPACE framework alongside sustained, voluntary adoption signals. Looking ahead, she stresses that autonomous agent workflows will fail without comprehensive system observability, while urging leaders to cultivate external peer advisory networks to protect themselves against burnout during rapid change.

## Atmosphere & style The presentation and fireside discussion feel refreshingly grounded, collegial, and clear-eyed, cutting through prevailing industry AI hype with data-driven realism and practical empathy. Forsgren delivers complex research insights with self-deprecating humor and sharp wit, easily trading knowing laughs with the host and audience over corporate bureaucracies and stubborn developer habits. The dynamic resembles an authentic, high-signal peer exchange among seasoned engineering leaders seeking practical clarity amid intense technological disruption.

## Bulletin - [01:39](https://www.youtube.com/watch?v=DfrAaDgFgjc&t=99s) Accelerating code generation through generative AI has intensified bottlenecks in the delivery outer loop, causing major backlogs in code reviews, releases, and security compliance. - [09:09](https://www.youtube.com/watch?v=DfrAaDgFgjc&t=549s) Instant feedback loops from autonomous AI agents paradoxically increase cognitive exhaustion, forcing engineers to rebuild their mental models dozens of times within 30-minute intervals. - [28:31](https://www.youtube.com/watch?v=DfrAaDgFgjc&t=1711s) Autonomous self-healing AI agents cannot operate effectively without lightweight, end-to-end system observability, as agents lack the informal human intuition and tribal knowledge needed to navigate fragmented architectures. - [17:53](https://www.youtube.com/watch?v=DfrAaDgFgjc&t=1073s) Measuring AI tooling ROI through raw activity metrics like lines of code or pull requests congests pipelines; evaluation requires multidimensional frameworks such as SPACE combined with voluntary adoption signals.

## Key takeaways - [00:09](https://www.youtube.com/watch?v=DfrAaDgFgjc&t=9s) Traditional productivity metrics are inherently flawed, but operating without signals leaves leadership vulnerable to relying on subjective gut feelings and vibes. - [01:39](https://www.youtube.com/watch?v=DfrAaDgFgjc&t=99s) AI tools accelerate the inner loop of coding, but this rapid generation throws fuel on existing outer-loop constraints in shipping and delivery. - [02:55](https://www.youtube.com/watch?v=DfrAaDgFgjc&t=175s) Distrust of AI-generated code has prompted organizations to roll back automated review mechanisms, overwhelming human reviewers with routine changes. - [04:14](https://www.youtube.com/watch?v=DfrAaDgFgjc&t=254s) Legacy enterprise onboarding and security structures fail to support day-one developer productivity, stalling AI-accelerated engineers behind access delays and identity verification. - [07:00](https://www.youtube.com/watch?v=DfrAaDgFgjc&t=420s) Clear documentation, clean architecture, and explicit API contracts reduce cognitive load symmetrically for both human engineers and autonomous agents. - [09:09](https://www.youtube.com/watch?v=DfrAaDgFgjc&t=549s) Sub-minute agentic feedback disrupts sustained flow state by forcing developers to continuously evaluate and reconstruct their internal understanding of code. - [09:09](https://www.youtube.com/watch?v=DfrAaDgFgjc&t=549s) Practitioners increasingly manage agent-induced cognitive overload by silencing auto-complete or running agents asynchronously in isolated sessions. - [12:00](https://www.youtube.com/watch?v=DfrAaDgFgjc&t=720s) Tooling alone cannot establish flow state; developers require psychological safety, well-scoped requirements, and organizational context to perform effectively. - [12:00](https://www.youtube.com/watch?v=DfrAaDgFgjc&t=720s) AI agents act like uncritical sycophants, lacking the authentic peer friction and pushback necessary to identify architectural blind spots. - [14:00](https://www.youtube.com/watch?v=DfrAaDgFgjc&t=840s) The manual effort of drafting, failing, and iterating remains a fundamental cognitive requirement for comprehending complex systems and building accurate mental models. - [17:53](https://www.youtube.com/watch?v=DfrAaDgFgjc&t=1073s) The SPACE framework provides a balanced approach to developer productivity by linking satisfaction, performance, activity, collaboration, and efficiency. - [17:53](https://www.youtube.com/watch?v=DfrAaDgFgjc&t=1073s) High-performing engineering teams treat intentional velocity trade-offs as informed, risk-based operational decisions rather than sacrifices of quality. - [20:55](https://www.youtube.com/watch?v=DfrAaDgFgjc&t=1255s) The democratization of AI coding tools to non-technical staff introduces critical security vulnerabilities, necessitating updated governance and dual-party review models. - [22:38](https://www.youtube.com/watch?v=DfrAaDgFgjc&t=1358s) Voluntary adoption and engagement depth serve as reliable diagnostic proxies for tool value, as developers actively discard inefficient tooling. - [24:54](https://www.youtube.com/watch?v=DfrAaDgFgjc&t=1494s) Explicit executive sponsorship granting time to experiment provides the psychological safety required for engineers to adopt AI without fear of retribution. - [26:52](https://www.youtube.com/watch?v=DfrAaDgFgjc&t=1612s) Engineering leaders need informal advisory peer networks, or personal boards of directors, to process ambiguous changes and mitigate burnout rooted in misaligned values. - [28:31](https://www.youtube.com/watch?v=DfrAaDgFgjc&t=1711s) Compression of the software delivery lifecycle will expand from coding into the outer loop, requiring proactive re-evaluation of deployment gates. - [31:18](https://www.youtube.com/watch?v=DfrAaDgFgjc&t=1878s) Cross-company peer networks and backchannels provide vital calibration against insular corporate thinking during periods of rapid technological disruption.

## Detailed walkthrough ### [00:09](https://www.youtube.com/watch?v=DfrAaDgFgjc&t=9s) The Problem with AI Vibes and Productivity Metrics

Nicole Forsgren is welcomed to the stage, marking a reunion since her previous long-form conversation on the podcast prior to the release of her book *Frictionless*. Now at Google, Forsgren focuses on improving how software is built and navigating the evolving relationship between developers and AI agents. Referencing an earlier talk by Laura, Forsgren jokes, “If we can't call it developer experience, just call it agent experience and then it's all going to work.” A central challenge remains measuring developer productivity—a problem that Martin Fowler had pointed out earlier was already flawed and has become significantly more complicated with AI.

Forsgren argues that although productivity metrics are frequently disliked because they can feel like a personal attack, operating completely without them leaves teams stranded on mere impressions:

> “I'm sure we've all been in a meeting with a director or a VP or something where they like just have a gut feel. Is this just how we should go? You know, they don't seem to be super open to it if agents just go on gut feel. So having some kind of signal's helpful.”

- The discussion highlights the shift from developer experience (DevEx) to agent experience (AX). - Traditional productivity metrics were already flawed, but GenAI tooling has amplified measurement difficulties. - Reliable signals are necessary to prevent strategic decisions from being driven purely by leadership “vibes” and gut feelings.

---

[01:39](https://www.youtube.com/watch?v=DfrAaDgFgjc&t=99s) Inner-Loop Acceleration vs. Outer-Loop Bottlenecks

A major paradox highlighted in *Frictionless* is that while AI empowers teams to generate code faster than ever, the actual delivery and shipping process remains painfully slow. Forsgren explains that early industry excitement heavily concentrated on GenAI within the coding "inner loop" because that is where the immediate visual feedback and dopamine hits occur. Meanwhile, legacy delivery systems—once considered "fine" despite minor inefficiencies—are being overwhelmed by sheer volume.

Citing Tiwa's earlier talk on chasing constraints, Forsgren notes that adding AI to the inner loop has acted as an accelerant on dormant structural issues:

> “Well, now we just threw gas on the fire and so all of that is a problem. And so, what we're doing I I liked how, you know, Tiwa mentioned it this morning. Now we're kind of chasing those constraints, we're chasing the bottlenecks in a way that it's much more obvious than it was in the past.”

```mermaid flowchart LR accTitle: Inner Loop Acceleration vs Delivery Bottlenecks accDescr: Diagram illustrating fast AI-assisted code generation hitting human and process bottlenecks during shipping.

subgraph InnerLoop["Fast Inner Loop (AI-Assisted)"] A["GenAI Coding Tools"] --> B["Rapid Code Creation\n& Immediate Dopamine"] end

subgraph OuterLoop["Constrained Outer Loop (Shipping)"] B --> C["Security Reviews"] B --> D["Human Code Reviews"] B --> E["Deployment & Release Gates"] end

C --> F["Delivery Delay\n& Backlog"] D --> F E --> F ```

---

[02:55](https://www.youtube.com/watch?v=DfrAaDgFgjc&t=175s) Review, Release, and Deployment Constraints

When asked for concrete examples of where teams get bogged down, Forsgren points directly to code review, deployment, and release engineering. Code review is especially strained: humans were already the primary bottleneck, but the problem has intensified because teams have actually begun rolling back automated review tooling. Out of fear over AI code verifiability and reliability, organizations are forcing humans to scrutinize routine changes that previously bypassed manual inspection.

The release and deployment phase represents another severe operational barrier. Often treated as an opaque black box, release management frequently relies on manual human sense-making:

> “That doesn't scale if you have one or two or a handful of people trying to make group decisions and do group sense making.”

- **Review Burden Shift**: Automation for routine changes is frequently disabled due to distrust of AI-generated code, increasing human review overhead. - **Release Complexity**: Selecting candidate builds, verifying dependencies, cherry-picking commits, and rebundling remain largely human-driven tasks. - **Scale Failure**: Small groups of release engineers cannot process the surge of inbound pull requests generated by AI-assisted developers.

---

[04:14](https://www.youtube.com/watch?v=DfrAaDgFgjc&t=254s) Organizational Process Debt and Onboarding Friction

The discussion turns to an example from *Frictionless* where a new hire, writing code with AI on day one, is left waiting two to three weeks for code reviews and database access. The host contrasts this with startups where rapid shipping is standard, asking how common such slowdowns are. Forsgren answers wryly:

> “Organizations are still going to organize, right?”

She points out that while forward-thinking companies like Etsy intentionally engineered their onboarding so engineers could commit code on day one, most traditional enterprises never planned for that level of velocity. Companies have applied AI tools to code creation, but have neglected the human and operational business processes surrounding it.

Forsgren shares an anecdote about an intern who, due to corporate policies and supply chain snafus, had to work on a loaner laptop for two weeks. The intern committed significant volumes of code before the official machine arrived. However, when attempting to push to a particularly secure component, the entire pipeline stalled because the security framework rejected the commit when the machine identity did not match the expected source.

- Process structures originally implemented to guarantee uniformity now act as primary friction points. - Missing database access for two weeks was tolerable when onboarding was slow, but it paralyses modern, AI-accelerated developers. - Corporate identity verification and security systems frequently reject commits from temporary hardware or non-standard workflows.

---

[07:00](https://www.youtube.com/watch?v=DfrAaDgFgjc&t=420s) Cognitive Load, Flow State, and Developer Experience

Turning to measurement frameworks—from DORA and SPACE to the DevEx framework—the host asks how core pillars like cognitive load map onto the AI era. Forsgren reviews the three interconnected components of DevEx: flow state, feedback loops (prompted from the audience by Laura), and cognitive load. Long waits for review responses or approvals disrupt flow state, which immediately exacerbates mental strain.

Forsgren emphasizes that while challenging work inherently requires mental effort, arbitrary operational friction represents wasted brainpower:

> “And that's where, you know, I thinking about the human can be really helpful because, you know, it was called out in a couple talks earlier, what's good for humans is good for systems.”

Well-structured documentation, clean codebases, and explicitly defined API contracts benefit human developers and AI agents alike by eliminating extraneous cognitive load. Referencing research by Gloria Mark on focus limits, Forsgren transitions into examining how developer attention spans and cognitive capacity operate under persistent context switching.

- **DevEx Core Pillars**: Flow state, feedback loops, and cognitive load mutually reinforce developer efficiency. - **Cognitive Waste**: Arcane processes, multi-step bureaucracy, and context switching consume mental energy without adding value. - **Symmetrical Benefits**: Modular architecture and clear documentation provide identical clarity to human engineers and autonomous agents.

[09:09](https://www.youtube.com/watch?v=DfrAaDgFgjc&t=549s) Cognitive Load and the Paradox of Fast Feedback Loops

Human beings can sustain roughly three to four hours of intense, deep intellectual work per day. Nicole Forsgren laughs at corporate executives who insist that their teams deliver eight full hours of relentless focus every single day, flatly noting that human biology simply does not function like that. Historically, software engineers cultivated those precious deep-work hours by blocking out their calendars, eliminating interruptions, and immersing themselves in a single complex problem. With the rise of AI assistants and coding agents, that dynamic has been upended. Many modern AI models are highly interruptive, continually pinging users or injecting auto-completions before an engineer has even framed their next line of thought.

```mermaid flowchart TD accTitle: Cognitive Load in Traditional vs AI Feedback Loops accDescr: A comparison showing how traditional feedback loops allowed continuous mental focus while rapid AI loops force frequent mental model rebuilds.

subgraph Traditional["Traditional Feedback Loop"] A["Write code or ask question"] --> B["Mild pause / waiting"] B --> C["Mental model stays intact"] end

subgraph AILoop["Rapid AI Agent Loop"] D["Prompt AI or Agent"] --> E["Instant code generation"] E --> F["Forced to rebuild mental model"] F -->|"Repeats dozens of times in 30 min"| D end ```

This dynamic introduces a perplexing paradox into software development. For decades, the engineering industry treated rapid feedback loops as the holy grail of software delivery; the faster the loop, the better the outcome. Yet tools like Claude Code now deliver feedback so rapidly that engineers find themselves mentally exhausted rather than energized. As Forsgren explains, past feedback delays—such as asking a colleague about a library and waiting for a response—still allowed an engineer to hold their cognitive state intact while continuing their work. In contrast, sub-minute agentic feedback forces developers to constantly evaluate, dismantle, and rebuild their internal understanding of the code base.

To survive this firehose of information, engineers are starting to invent their own personal containment strategies. Forsgren admits that she frequently turns auto-complete off entirely just to get her raw thoughts onto the screen before inviting the AI back in to review what she has produced. The host adds that Mitchell Hashimoto, the founder of HashiCorp, adopted a parallel strategy: Hashimoto keeps an AI agent running in a side-by-side terminal session but disables all notifications completely. Hashimoto fires off tasks to the agent asynchronously and inspects the output only when he has reached a natural stopping point, refusing to let the machine dictate his attention.

- Humans can only sustain three to four hours of genuinely intense deep cognitive work each day. - Rapid feedback loops previously preserved developer focus, but near-instant agent output forces engineers to rebuild their mental models dozens of times within half-hour intervals. - Industry practitioners are pushing back against constant interruption; Mitchell Hashimoto silences all agent notifications to process agent outputs purely on his own schedule.

> “Well, now I'm getting feedback so quickly that I'm having to sometimes rebuild my mental model dozens of times in like a 30-minute period.” — Nicole Forsgren

---

[12:00](https://www.youtube.com/watch?v=DfrAaDgFgjc&t=720s) Flow State, Psychological Safety, and Sycophantic "Genies"

While AI tooling is frequently marketed as a guaranteed path into uninterrupted flow, tooling alone cannot create a high-performing engineering environment. Drawing from the research in her book, Forsgren reiterates that achieving flow state depends overwhelmingly on human and organizational conditions: clear project goals, well-scoped problems, genuine technical autonomy, and psychological safety. Engineers cannot enter flow if they do not understand the broader purpose of what they are building or if they fear the consequences of taking an educated technical risk.

Forsgren highlights the critical gap between human collaboration and interacting with generative models. Referencing Kent Beck’s metaphor of AI agents as "genies," Forsgren points out that commanding a suite of genies is fundamentally different from collaborating with human teammates. Teammates bring distinct social energy, divergent perspectives, and critical pushback. AI models, by contrast, behave like compulsive sycophants that incessantly praise the user's ideas, no matter how misguided those ideas might actually be.

This uncritical validation undermines one of the most vital stages of creative and technical work: finding blind spots. In Forsgren's own writing and research, human review is essential to point out where an argument collapses, where logic leaps too far, or where an explanation only makes sense inside the author's own head. Current AI agents are simply incapable of playing that role reliably; they either offer shallow praise or make wild guesses in completely irrelevant directions.

- Flow state depends primarily on psychological safety, well-scoped requirements, and understanding organizational purpose rather than advanced tooling alone. - Working alongside AI "genies" lacks the authentic friction and critical peer feedback required to refine complex systems. - Generative tools default to constant agreement and flattery, blinding developers to their own design flaws and errors.

> “Tech is easy, people are hard.” — Nicole Forsgren

> “We may have a handful of genies, but that's different from having a handful of friends, right? In part because the energy's different, the conversations are different.” — Nicole Forsgren

---

[14:00](https://www.youtube.com/watch?v=DfrAaDgFgjc&t=840s) The Value of Wasted Effort and Mental Model Construction

Forsgren shares a cautionary personal story about the pitfalls of unguided flow state while writing her book, *Frictionless*. Coming from a background as both a software engineer and an academic researcher, she had internalized academic writing habits where authors provide exhaustive background and methodological scaffolding, only reaching their actual thesis around page 105. After writing deep in a flow state, she looked up to find that she had produced several complete chapters—over one hundred pages—detailing how non-researchers should conduct surveys and interview subjects. While the text was clear and comprehensive, she realized that nobody buying the book would ever want to read it.

She scrapped the entire 100-page section, reached out to Abby Nida to co-author the book, and asked Nida to act as a guardrail against future rabbit holes. They salvaged the core insights by transforming them into concise, actionable workbooks with fillable tables at the back of the book. Reflecting on this experience, the host asks whether the modern drive to "one-shot" solutions using AI risks stripping away the necessary struggle that leads to true clarity. Forsgren agrees, observing that without the physical and mental effort of attempting, failing, and reformulating an idea, human brains rarely develop a genuine grasp of the problem.

This dynamic poses a serious question for modern software development. In traditional development, engineers built an intuitive mental map of large codebases through the deliberate, tactile act of writing code and whiteboarding architectural boundaries. As AI-assisted tools accelerate code generation, developers risk losing touch with the systems they supposedly own. To counteract this loss of comprehension, Forsgren frequently instructs AI assistants to generate Mermaid diagrams, using visual diagrams as an external whiteboard to help her brain grasp complex architectures.

- Academic and engineering flow states can easily lead to writing at the wrong altitude or for the wrong audience without early external calibration. - Forsgren discarded over 100 pages of research methodology content while drafting *Frictionless*, converting the practical portions into structured workbooks alongside co-author Abby Nida. - The manual effort of drafting and failing is an essential cognitive mechanism for articulating problems clearly and constructing accurate mental models. - Forsgren uses AI to generate Mermaid diagrams to visually map system architectures and maintain cognitive control over rapidly shifting code.

> “Without trying, I don't get there.” — Nicole Forsgren

> “And on page like 105 you get to the point.” — Nicole Forsgren

---

[17:05](https://www.youtube.com/watch?v=DfrAaDgFgjc&t=1025s) The Executive Dilemma: Measuring AI ROI

The conversation turns to the mounting pressure facing engineering leaders across the tech industry. Chief executive officers, board members, and finance executives have approved massive expenditures on AI tooling, licenses, and infrastructure, and they are demanding concrete proof of business impact. Leaders want to know what metrics Nicole Forsgren recommends to quantify their return on investment.

Acknowledging that answering this question is quite literally her core profession, Forsgren delivers the classic, inescapable industry reality: it depends. She jokes with the host that relying on that universal answer means everyone in the room can easily transition into consulting and make vast amounts of money, before preparing to unpack how organizations must ground their metrics in context rather than simplistic, top-down numbers.

- Executives and corporate boards are demanding hard ROI metrics after authorizing substantial financial investments into developer AI tooling. - Engineering leaders frequently look for standardized metric formulas from industry authorities to justify tooling adoption to their executive suites.

> “It is always it depends.” — Nicole Forsgren

> “We can all go into consulting now and just make a ton of money.” — Nicole Forsgren

[17:53](https://www.youtube.com/watch?v=DfrAaDgFgjc&t=1073s) Deconstructing Productivity and the SPACE Framework

When leaders ask whether they or their teams are becoming more productive, Nicole Forsgren pushes back by interrogating what they actually mean by the word. Productivity is not self-evident; just as code smells indicate underlying architectural flaws, "productivity smells" expose flawed assumptions about work. Leaders frequently gravitate toward counting raw outputs like lines of code or pull requests, but Forsgren challenges the utility of these metrics: does producing more code actually help ship features to customers faster, and even if it does, is it the right feature? Simply amplifying raw output across the entire pipeline—demanding more ideas, more code, and more reviews—merely congests the organization without delivering value.

```mermaid flowchart TD accTitle: SPACE Framework Dimensions accDescr: The five interrelated dimensions of developer productivity according to the SPACE framework. subgraph SPACE["SPACE Framework"] S["Satisfaction<br/>(Fulfillment & tool perception)"] P["Performance<br/>(Outcomes, quality, impact)"] A["Activity<br/>(Countable outputs & actions)"] C["Collaboration & Communication<br/>(Interpersonal & system interactions)"] E["Efficiency & Flow<br/>(Time to value & cognitive continuity)"] end S <--> P P <--> A A <--> C C <--> E ```

To measure productivity meaningfully without falling into brute-force traps, Forsgren advocates using the multidimensional SPACE framework:

- **S — Satisfaction**: Gauges developer sentiment and fulfillment with their tools and processes. - **P — Performance**: Focuses on outcomes and quality rather than sheer activity. - **A — Activity**: Covers countable counts and outputs (PRs, commits, operational events). - **C — Collaboration and Communication**: Examines interactions across people and increasingly between human engineers and automated systems. - **E — Efficiency and Flow**: Tracks both subjective mental flow states and systemic latency (the calendar time required for work to clear the delivery pipeline).

Forsgren notes that although many organizations obsess over raw velocity, speed without proper guardrails around quality and developer satisfaction guarantees systemic failure. When high-performing teams deliberately trade off traditional quality markers for raw speed, they do not view it as negligence. As Forsgren highlights: “They don't say they're sacrificing quality. They say they're making a risk-based decision.” In practice, this means shipping rapid experiments to a minuscule slice of production traffic—accepting isolated latency spikes or localized crashes for an hour—to capture clear signal before rolling back and making an informed decision.

[20:55](https://www.youtube.com/watch?v=DfrAaDgFgjc&t=1255s) Security Pressures and Changing Governance Guardrails

While product teams seek to move faster, security teams often operate in pure brake-pumping mode, leaving them overwhelmed as modern tooling expands outside traditional engineering confines. The host shares an anecdote from an event the previous evening featuring David Cramer from Sentry, who noted that non-developers across the business are adopting AI coding tools (such as Claude Code) to build internal software. In one notable case at a large publicly traded company, a business developer built an internal tool to analyze sales proxies and inadvertently exposed it publicly to the entire internet. While the leak was caught in time, incidents like this illustrate why security teams are suddenly under immense strain. Cramer pointed out that standard annual developer security training—routinely met with a collective yawn—must transform into engaging, interactive sessions required for all employees across the enterprise.

Forsgren agrees that it is a pivotal era for the security field, noting that definitions of risk, compliance, and validation are fundamentally shifting:

- Regulatory requirements historically mandated strict four-eyes policies—insisting that at least two human engineers review code before it reaches production. - Over the past two decades, forward-thinking organizations successfully lobbied regulators to accept automated testing suites and CI/CD policy gates in lieu of one human reviewer. - As autonomous AI coding agents enter the pipeline, leadership and regulators must rethink whether agentic code generation paired with agentic review meets the bar for dual-party verification. - Engineering leadership must take an active role in discovering and establishing these new review paradigms to educate internal teams as well as external regulatory bodies.

[22:38](https://www.youtube.com/watch?v=DfrAaDgFgjc&t=1358s) AI Metric Strategies: Adoption, Engagement, and Holistic Velocity

When engineering executives ask how to evaluate generative AI rollouts (whether Claude Code, OpenAI Codex, or other vendor platforms) without violating developer privacy or drowning in junk data, Forsgren begins with a nuanced look at adoption. Although she generally dislikes pure adoption metrics, she acknowledges their diagnostic power when dealing with software engineers. As Forsgren puts it: “devs are like a gloriously cranky bunch. We are not going to use tools that are awful unless we absolutely like if it's the only option, there's almost no other option.” She recalls a past client insisting that their engineering staff was completely locked into using the corporate CI/CD platform; Forsgren bet them $20 on the spot that engineers were covertly spinning up rogue Jenkins servers under their desks—and she won.

```mermaid flowchart LR accTitle: AI Evaluation Metrics Spectrum accDescr: Progression from basic usage signals to comprehensive delivery metrics. subgraph Surface["Diagnostic Signals"] Adopt["Adoption Rates<br/>(Voluntary uptake)"] Engage["Engagement Depth<br/>(Task complexity & repeat usage)"] end subgraph Deep["Systemic Outcomes"] Inner["Inner-Loop Latency<br/>(Typing & refactoring speed)"] Outer["Holistic Lead Time<br/>(Idea to deployed feature)"] end Adopt --> Engage Engage --> Inner Inner --> Outer ```

Because engineers aggressively discard useless tooling, sustained voluntary adoption serves as an early indicator of developer satisfaction. Beyond raw sign-ups, teams should evaluate engagement:

- Are engineers continuing to interact with the tooling over time, or did they test it once and walk away? - For what classes of tasks are they leaning on AI assistants? Early research demonstrates that developers rely on AI heavily for straightforward, boilerplate work, but drop off when tackling nuanced edge cases. - What specific outcome is leadership optimizing for? Inner-loop coding acceleration (typing and local refactoring) does not automatically translate into outer-loop business velocity (features delivered end-to-end to end users).

[24:54](https://www.youtube.com/watch?v=DfrAaDgFgjc&t=1494s) Executive Sponsorship and Psychological Safety in AI Adoption

The host brings up an initiative implemented by Rajeev Rajan (Atlassian's CTO and upcoming summit speaker), who sent an organization-wide memo granting staff explicit permission to spend 10% of their working hours experimenting with AI tools and discovering how they function. The host asks whether this top-down mandate is genuinely effective in creating space for technological change.

Forsgren affirms that explicit executive cover is indispensable, blending traditional change management and corporate communications with the realities of modern engineering anxiety. Because software developers harbor deep anxieties around using generative AI—worrying whether generating code with these tools will get them reprimanded, fired, or blamed for production failures—clear, public executive backing provides necessary psychological safety:

- “...explicit exec sponsorship makes a huge difference in not just using them, but trying new things and feeling safe to fail within, you know, kind of guardrails.” - Giving engineers explicit permission removes ambiguous compliance hurdles, transforming cautious curiosity into active system pressure-testing. - This dynamic parallels long-standing engineering cultures where teams hand out prizes or recognition to engineers who accidentally take down production, intentionally de-stigmatizing calculated operational risk in order to surface latent systemic weaknesses.

[26:15](https://www.youtube.com/watch?v=DfrAaDgFgjc&t=1575s) Supporting Oneself Through Organizational Friction

Transitioning toward the practical realities of managing prolonged systemic disruption, the host highlights a specific chapter from Forsgren's book, *Frictionless* (which explores eliminating organizational friction and accelerating engineering flow). Toward the end of the text, Forsgren dedicates an entire standalone chapter titled "Support Yourself Through Challenging Work." The host prompts Forsgren to unpack why she prioritized self-support and personal resilience alongside technical and organizational practices, and how leaders, peers, and individual contributors can sustain themselves through an exceptionally intense technological era as organizations undergo radical change.

[26:52](https://www.youtube.com/watch?v=DfrAaDgFgjc&t=1612s) Supporting Leaders Through Change and Battling Burnout

When engineering organizations undertake massive transformations—whether kicking off a brand-new Developer Experience (DevEx) initiative or rolling out generative AI tooling—leaders often focus entirely on guiding their teams while forgetting to support themselves. Nicole Forsgren emphasizes that executive, formal support for teams is standard, but leaders themselves are navigating uncharted waters with immense ambiguity and pressure. Referencing conversations with dozens of engineering leaders while writing her work, Forsgren notes that many highlighted the necessity of building an informal advisory support system. As Forsgren recalls, “Rose Whitley said you should have your own board of directors.” Having such a circle provides a safe, low-stakes space to admit confusion before high-stakes meetings: leaders can candidly say, “I have to go to an exec review, and I need to have an opinion, and like, I understand half of this. Like, can you talk this through with me?”

This support mechanism also acts as a vital buffer against executive burnout. Referencing the pioneering research of Christina Maslach, Forsgren points out that burnout is frequently misunderstood. Working excessively hard causes fatigue, but true burnout stems from deeper organizational and psychological mismatches. As Nicole Forsgren explains, “Another piece that's super critical to burnout is not having your values aligned.” When leaders can talk through complex situations with trusted peers, they often uncover whether their personal values truly align with organizational goals or if friction is distorting their perspective. In many instances, clarifying these core values relieves the intense, isolating pressure leaders carry during organizational shakeups.

- **The Personal Board of Directors:** An outside council of trusted peers acts as an intellectual sounding board for half-formed strategies before leaders enter formal executive reviews. - **Fatigue vs. Burnout:** Christina Maslach's research differentiates simply working too hard (which just produces physical tiredness) from true burnout, which heavily involves a breakdown in value alignment.

---

[28:31](https://www.youtube.com/watch?v=DfrAaDgFgjc&t=1711s) The Frictionless Future: System Observability for Humans and AI Agents

Looking ahead two to three years, the interviewer asks how an organization that genuinely commits to eliminating friction and adopting AI tools will operate, and where engineering leaders should begin their journey today. Forsgren, self-identifying as a metrics and data specialist, tackles the question through the lens of system visibility and software lifecycle shifts. While the current industry narrative envisions autonomous AI agents that can self-drive, self-heal, and continuously improve codebases and workflows, Forsgren stresses that this future hinges on foundational observability: “For that to be true, agents need to be able to see and understand the system.”

Currently, human developers act as the primary stopgap within fragmented architectures, using tribal knowledge and ad hoc conversations to diagnose problems—instinctively knowing, for instance, that when a specific downstream service fails, the root cause is almost always in the build pipeline. Autonomous agents cannot rely on that informal human intuition, nor would organizations want them guessing blindly. Consequently, organizations must create lightweight, cheap mechanisms to instrument and surface telemetry signals across the entire development cycle. The front end of software engineering—ideation, design, and coding—has already been compressed into rapid prototyping with AI assistance. Forsgren predicts that the outer loop will inevitably follow suit: “I fully expect that part of the outer loop is just going to be collapsed as well, right? Because we'll find more efficient ways to do that.” As release, review, and deployment pipelines compress, leaders must proactively identify where their quality gates and feedback signals reside, tracking how they shift or whether legacy gates can safely disappear.

```mermaid flowchart LR accTitle: System Observability Preconditions for Autonomous AI accDescr: A flow showing the prerequisite chain required for self-improving AI agents, starting from system instrumentation to agent execution.

subgraph Observability ["System Visibility"] A["Surface Cheap Signals & Telemetry"] --> B["Humans See & Understand System"] end

subgraph Agency ["Action & Improvement"] B --> C["Agents See & Understand System"] C --> D["Autonomous Outer-Loop Fixes"] end ```

- **Prerequisites for Autonomous Agents:** AI agents cannot autonomously remediate or optimize systems unless those systems are comprehensively instrumented and visible to human operators first. - **Compression of the Lifecycle:** The inner loop (ideating, designing, and coding) has already collapsed into rapid AI-assisted prototyping; the outer loop (testing, review, compliance, deployment) is next in line to be consolidated. - **Resource Note:** Forsgren mentions that companion workbooks for her book are available for free online alongside her published materials.

---

[31:18](https://www.youtube.com/watch?v=DfrAaDgFgjc&t=1878s) Peer Networks, Backchannels, and Collective Sense-Making

Because the trajectory of software engineering in the age of AI is shifting so rapidly, both the host and Forsgren agree that creating external, cross-company networks is essential for survival and clarity. Setting up informal WhatsApp threads, group chats, or regular coffee catch-ups with peers across different organizations gives leaders a reality check outside their company bubble. Because every engineering context is nuanced and subject to the classic rule of "it depends," comparing notes with peers facing similar industry constraints makes those dependencies comparable and actionable.

Forsgren relies heavily on her own trusted backchannel to reality-test emerging patterns and avoid organizational echo chambers. When new challenges arise, she uses these groups to calibrate her observations: assessing whether what she is seeing matches what peers are experiencing, determining whether disagreements are substantive or merely semantic, and evaluating whether her explanations hold water. As Nicole Forsgren emphasizes about navigating continuous industry volatility, “And so that, I think especially when we're in a time of change at all, but especially this rapid, it's super super helpful.” Having a low-friction, psychologically safe backchannel with respected peers allows leaders to ask vulnerable questions, share early data, and build resilience together.

## Notable quotes > [26:52](https://www.youtube.com/watch?v=DfrAaDgFgjc&t=1612s) Another piece that's super critical to burnout is not having your values aligned. — Nicole Forsgren

> [07:00](https://www.youtube.com/watch?v=DfrAaDgFgjc&t=420s) what's good for humans is good for systems. — Nicole Forsgren

## Mentioned Nicole Forsgren, Frictionless, Accelerate, Nik Koblov, Veeral Patel, Will Koh, Ian Tracey, Martin Fowler, Kent Beck, Mitchell Hashimoto, HashiCorp, Abby Nida, Gloria Mark, Christina Maslach, Rose Whitley, David Cramer, Sentry, Rajeev Rajan, Atlassian, Google, Etsy, Claude Code, OpenAI Codex, Jenkins, DORA, SPACE framework, DevEx framework

## Video description With Nicole Forsgren, author of Frictionless and Accelerate. At The Pragmatic Summit: www.pragmaticsummit.com

With Nik Koblov (EVP Engineering), Veeral Patel (Director, Applied AI and Spend), Will Koh (Staff Engineer, Applied AI), and Ian Tracey (Staff Software Engineer). Recorded at The Pragmatic Summit www.pragmaticsummit.com

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

0:00 Intro 2:45 Inner-loop acceleration vs outer-loop bottlenecks 6:20 Review, release, and deployment constraints 10:35 Organizational process debt 14:20 Cognitive load and flow disruption 18:05 Psychological safety, ownership, and decision quality 22:00 Metric strategy with AI 27:05 Why adoption metrics alone are insufficient 35:30 Leadership change management: top-down + bottom-up 39:20 Frictionless future

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

Reading summary

Nicole Forsgren argues that while generative AI dramatically accelerates initial code generation, it exacerbates delivery bottlenecks across review and release pipelines while creating severe cognitive fatigue. She contends that sustainable engineering performance depends on system-wide observability, human-centered cognitive guardrails, and multidimensional metrics rather than raw output tracking. Inner-Loop Acceleration Exposes Delivery Bottlenecks (1:39) While generative AI tools accelerate the coding "inner loop," organizations face severe operational gridlock in their "outer loop" of code reviews, deployment pipelines, and release gates. Forsgren observes that adding AI to code generation acts as an accelerant on dormant structural issues: legacy delivery workflows and small release engineering teams cannot scale manual sense-making to match the surge in AI-generated pull requests. Rather than accelerating end-to-end delivery, organizations find their downstream pipelines overwhelmed. This friction is compounded by operational process debt and heightened risk aversion. Forsgren notes that out of distrust for the verifiability of AI-generated code, some teams have rolled back automated review systems, forcing human reviewers to manually inspect routine modifications. Consequently, even when developers write code on their first day using AI, structural bottlenecks—such as multi-week waits for database access or security pipelines rejecting commits from temporary loaner laptops—stall features before they can reach production. Rapid Feedback Loops and Cognitive Exhaustion (9:09) Software engineers can sustain roughly three to four hours of deep cognitive focus per day, a threshold increasingly disrupted by modern AI assistants. Forsgren highlights an emerging paradox: while rapid feedback loops were historically considered the gold standard of software delivery, sub-minute agentic feedback now forces developers to constantly evaluate, dismantle, and rebuild their internal mental models dozens of times within a 30-minute window. To protect their focus, practitioners such as Mitchell Hashimoto and Forsgren herself frequently disable auto-completions or silence agent notifications until reaching natural stopping points. Furthermore, Forsgren cautions against relying on AI tools for collaborative reflection. Citing Kent Beck's framing of AI models as "genies," she notes that generative assistants behave like sycophants that uncritically flatter the user's ideas. Unlike human teammates who provide divergent perspectives, social energy, and critical pushback, AI models fail to expose an author's blind spots. Bypassing the friction of manual drafting and reformulation risks preventing engineers from developing a sound grasp of complex architectures. Measuring Productivity Beyond Raw Activity Metrics (17:53) Facing mounting executive pressure to prove return on investment for AI expenditures, engineering leaders frequently default to counting raw outputs such as lines of code or pull requests. Forsgren characterizes this approach as a "productivity smell" that clogs delivery pipelines without verifying whether teams are shipping the right features to customers. Instead, she advocates evaluating engineering performance through the multidimensional SPACE framework: Satisfaction, Performance, Activity, Collaboration and Communication, and Efficiency and Flow. When tracking AI adoption, Forsgren emphasizes voluntary, sustained engagement over raw seat counts. Because software developers aggressively discard tools that hinder their workflow, voluntary uptake serves as an early indicator of tool utility. She notes that while developers readily leverage AI for straightforward boilerplate work, usage drops when tackling nuanced edge cases. Evaluating tools requires understanding this task complexity, ensuring leaders do not mistake local typing speed for end-to-end lead time from concept to customer value. System Observability and Navigating Transformation (28:31) Looking toward an envisioned future where autonomous agents remediate and improve codebases, Forsgren asserts that agency depends entirely on system observability. Because agents lack the informal human intuition and tribal knowledge developers use to diagnose pipeline failures, organizations must instrument lightweight telemetry across the entire development lifecycle so that both humans and autonomous systems can interpret operational state. Concurrently, security and regulatory frameworks must evolve beyond historical human-only dual-control policies to define valid standards for agentic generation and review. To manage this transition without systemic exhaustion, Forsgren emphasizes executive sponsorship that grants explicit permission to experiment and fail safely. For engineering leaders navigating ambiguity, she cites Christina Maslach's research demonstrating that burnout stems primarily from organizational value misalignment rather than workload alone. Forsgren advises leaders to assemble an informal advisory "personal board of directors" and cross-company peer backchannels to reality-test emerging practices and sustain resilience through rapid technological change. Forsgren concludes that advanced tooling alone cannot manufacture engineering velocity without psychological safety, explicit architecture, and streamlined delivery pipelines. Whether autonomous agents can successfully collapse outer-loop deployment gates remains an open organizational question contingent on eliminating legacy process debt and standardizing end-to-end system telemetry.

Source quotes

[26:52] Nicole Forsgren: Another piece that's super critical to burnout is not having your values aligned. [7:00] Nicole Forsgren: what's good for humans is good for systems.

Original transcript

[0:09] Nicole, it is so nice to have you here. [0:12] Last time that you and me talked in more [0:14] long-form in a way that a lot of you [0:16] could enjoy was was on the podcast and [0:18] back then [0:19] Frictionless was not yet out. You were [0:21] working somewhere else. Now Frictionless [0:24] is out. Congratulations. You're now [0:26] doing a fun and exciting job at Google. [0:28] Can you tell us a little bit about what [0:30] you're what you're up to these days and [0:31] what keeps you up at night? [0:33] Oh my gosh, how much time do we have? [0:37] Um [0:38] very similar work, right? Like how can [0:39] we think about improving the way [0:43] people build software? How can we think [0:44] about I love that, you know, Laura [0:45] mentioned this this morning. If if we [0:47] can't call it developer experience, just [0:49] call it agent experience and then it's [0:51] all going to work. Um [0:53] thinking of ways that we can make agents [0:55] smarter and better so that we can work [0:58] with them better. Um how do we measure [1:00] really hard things like productivity [1:02] cuz, you know, Martin mentioned in the [1:04] last session um [1:06] the measurements were already like kind [1:08] of bad and now they're like extra bad. [1:10] So So how can we find ways because like [1:13] on the one hand we don't love a [1:14] productivity metric because it can feel [1:16] like an attack. But if we have nothing, [1:18] right? If this is just like [1:20] vibes. [1:22] I'm sure we've all been in a meeting [1:23] with a [1:24] director or a VP or something where they [1:26] like just have a gut feel. [1:28] Is this just how we should go? [1:30] You know, they don't seem to be super [1:32] open to it if agents just go on gut [1:34] feel. [1:35] So So having some kind of signal's [1:37] helpful. [1:39] One thing that that struck me about your [1:40] your book when [1:42] the very either the very beginning or or [1:44] or the back cover, it says that AI is [1:47] helping us create software faster than [1:49] ever and yet delivery or like shipping [1:53] is just still so slow. How do these [1:57] things [1:58] these two things go together? What what [2:00] is happening in between? So, I think [2:01] there's a few things, right? One is that [2:03] we all started focusing on GenAI in the [2:05] coding, you know, that inner loop [2:06] because we can see it and that's where [2:08] like all of the dopamine hit comes, [2:11] that's where it's all very exciting. And [2:12] then, as we go to ship, we've had [2:14] systems that like we already knew they [2:16] could probably be improved, but like it [2:18] was fine, right? There were a handful of [2:20] people probably managing a security [2:23] review process or a launch process or a [2:25] deployment process or, you know, [2:26] sometimes reviews were a little slow and [2:28] they got backed up. [2:29] Well, now we just threw gas on the fire [2:31] and so all of that is a problem. [2:33] And so, what we're doing I I liked how, [2:36] you know, Tiwa mentioned it this [2:37] morning. Now we're kind of chasing those [2:39] constraints, we're chasing the [2:40] bottlenecks in a way that it's much more [2:42] obvious than it was in the past. And so, [2:45] like in the immediate term, yeah, we [2:46] were getting more out, but now our [2:48] systems, whether technology systems or [2:50] human systems or processes, are really [2:52] kind of getting overwhelmed. [2:55] Do you have some some specific examples? [2:58] We don't need to name specific [2:59] companies, but like a a thing where [3:00] like, oh, you know, now they're using [3:02] all these AI tools, but these are the [3:03] things that are slowing them down. [3:05] There are a handful of things. So, uh [3:07] and it, you know, it kind of changes [3:09] depending on where they are in the [3:11] process. Review ends up surfacing quite [3:13] a bit, right? Because [3:15] we're just we're putting so much work on [3:17] it. And not only that, but like [3:19] humans were already a bit of a [3:20] bottleneck in the review process. [3:22] Now it can be worse because things that [3:24] we fairly straightforward changes that [3:26] some companies had automation around [3:28] reviewing, they've removed that [3:30] reviewing because if AI is involved and [3:32] they're worried about the verifiability [3:34] or the reliability of the code. And so, [3:35] now that review burden has shifted. I'm [3:38] also seeing quite a bit uh I still talk [3:40] to, you know, a handful of companies. [3:42] We're We're seeing quite a bit in that [3:44] deployment and release process, right? [3:46] That's [3:48] kind of empty black box for a lot of [3:49] folks who like don't know how the [3:51] sausage is made, but so many times that [3:54] process has been managed by humans [3:56] because you're selecting the right [3:57] candidate build and you're verifying it [3:59] and you're thinking, you know, you're [4:00] figuring out cherry picks and then you [4:02] like rebundle and then you send it out [4:05] and [4:06] that doesn't scale if you have one or [4:08] two or a handful of people trying to [4:10] make group decisions and do group sense [4:11] making. Mhm. [4:14] And in in in the book, I I realize the [4:16] book came out before Opus 4.5, but it [4:19] described this scenario which seems like [4:21] really alien, but obviously it's based [4:22] on a true story, that there's a new hire [4:24] joining a company [4:25] using AI tools. This person turns out [4:28] her first contribution and then for I [4:31] think two or three weeks it sits there [4:33] because the the code review didn't flag [4:36] it, she doesn't have access to the [4:37] database. [4:39] Can you tell me a little bit about like [4:40] some of these things? Like a lot of us [4:43] some people sitting here actually [4:44] working at startups where like it's just [4:45] a common thing to like go from like [4:47] deployment to shipping pretty quickly. [4:49] How [4:51] common are are these things which are [4:53] like just surprising people of like, oh, [4:55] these things are being stuck, people are [4:56] just fiddling their thumbs thumbs for a [4:58] while? And do you see this like being [5:01] the same? Do you see because of AI [5:03] pressure being on on removing these [5:04] things and recognizing them? What's what [5:06] are trends that you're observing? I [5:08] think one thing I'm saying that probably [5:09] won't surprise a bunch of folks here is [5:12] organizations are still going to [5:13] organize, [5:15] right? [5:15] So, like when you've got like some [5:17] review process and we wait two weeks or [5:19] like someone the one person has to sign [5:21] off on it, but that person's like, [5:22] "Oof." Or like all of the the things [5:26] that we have structured process around [5:28] to try to make things more uniform are [5:30] often the things that slow us down. And [5:31] so, [5:32] again, while we're kind of speeding up [5:34] that inner loop and now we're starting [5:35] to see agents do more around, uh, you [5:37] know, reviewing and and a handful of [5:39] other tasks, [5:41] a lot of companies haven't started until [5:43] now thinking about how we could apply AI [5:46] to the very human, very business process [5:50] part of it. [5:51] And so, that will keep slowing us down [5:54] until we find a way to to address it, [5:55] right? And a lot of that comes with when [5:57] I first start, you know, I get database [5:59] access, and not having database access [6:01] for 2 weeks is like historically usually [6:03] been fine. [6:04] Maybe not great, but like you not like [6:07] 90% of the time it was fine. Well, now [6:09] when you can be committing code on your [6:10] first day in ways that the [6:13] company wasn't necessarily structured [6:14] for, right? Like Etsy famously, you [6:16] know, you you would commit code on your [6:18] first day, but they knew that was [6:19] coming. All of these other companies [6:21] don't know that's coming. I knew of one [6:23] or two cases with an intern where [6:26] because of policies and a couple like [6:29] uh supply chain snafus, they didn't get [6:31] their laptop for like 2 weeks. [6:33] So, they were on a loaner. They had [6:35] committed a lot of code before their [6:36] laptop showed up, and like no one in the [6:39] system there was like one particularly [6:40] secure thing they were working on. They [6:42] couldn't figure out how to make that [6:43] work because it didn't match. [6:46] The source didn't match where they [6:47] thought it would. And so, I think we're [6:49] really seeing kind of an emphasis on a [6:51] spotlight on the things that were kind [6:54] of fine before, and it's that friction [6:56] that really slows us down now. [7:00] When one thing you've been like so good [7:02] at, and I paid so much attention to your [7:04] work, and I think it's influenced myself [7:06] and a lot of other people in the [7:07] industry, is is measuring how we can [7:09] measure these very hard to measure [7:10] things. And one of the the latest [7:14] you went through a lot of iterations. We [7:15] have Dora, we have space, we have the [7:17] DevEx framework, and and more. And in [7:19] the DevEx framework, this was pre-AI. [7:21] Can we talk a little bit about what the [7:22] DevEx framework is, and then like one [7:24] part of it is cognitive load, how that [7:26] feeds into AI? Yes. So, there are many [7:29] ways to think about developer [7:31] experience, but one that I find kind of [7:33] useful is there there are three pieces [7:35] that kind of fit together. So, there's [7:36] flow state, there's cognitive load, and [7:39] there's Why am I forgetting last one, [7:40] Laura? [7:41] Feedback loops. Feedback loops. [7:43] I'll look at Laura. [7:44] Thanks, Laura. [7:46] Um [7:47] and they all kind of support each other, [7:49] right? Because when I'm in the flow, the [7:51] feedback loops are really important. If [7:52] I have to wait [7:54] 20 minutes, if I have to wait a week to [7:56] get something an answer [7:58] uh a question answered or a review back, [8:01] then I break my flow. Um that makes it [8:02] harder for cognitive load as well. So, [8:04] cognitive load is basically like the [8:05] work that our brain needs to do. And [8:07] there is some inherent level of [8:08] cognitive load in something we do, [8:10] right? So, something that's difficult is [8:12] going to take more brain power, but [8:13] things that are easy [8:15] easy should not take brain power. But [8:17] like sometimes revamping into a a code [8:19] base when we haven't been into it for a [8:21] while, that's higher cognitive load. And [8:22] so, if I'm already there, I can get a [8:24] bunch of that work for free. Or anytime [8:27] I have to deal with like a really arcane [8:29] process and go through 100 steps, it's [8:31] easy cuz it's straightforward, but it [8:32] takes a lot of work, right? And that's [8:35] where, you know, I [8:37] thinking about the human can be really [8:39] helpful because, you know, it was called [8:40] out in a couple talks earlier, what's [8:42] good for humans is good for systems. If [8:43] I have well-structured code, if I have [8:45] well-structured documentation, if I have [8:48] uh APIs that are like clearly defined [8:51] and I I know what those interfaces look [8:53] like, it can be really helpful. And [8:55] then, I will say it's it's kind of [8:57] revisiting this question of now of how [8:59] do we want to think about cognitive [9:01] load? [9:02] Because I want to say Gloria Mark has [9:04] done some really incredible work on [9:06] focus. And humans max out at about like [9:09] 3 to 4 hours a day. Like really really [9:11] hard deep work, right? Um [9:14] which always makes me laugh when [9:15] executives are like, "We need 8 hours of [9:17] intense work." And I'm like, "Not with [9:18] humans." That's Our brains don't do [9:21] that. And so now, when we have these 3 [9:23] or 4 hours, how can we use them best? [9:25] And what does it mean when we're working [9:28] with AI and with agents? Because for [9:30] some of us, [9:32] um good deep work means I block my [9:34] calendar and I can get really embedded [9:36] and I can do one thing and I can think [9:37] really hard. And now a lot of the models [9:40] are very interruptive, right? I'm [9:42] getting pinged all the time. And so how [9:44] can I [9:45] change the way I work or how can I think [9:48] about managing my own cognitive load and [9:50] how can we think about it more broadly [9:51] in organizations knowing that the nature [9:54] of the work that we're doing and many [9:55] times has really changed? [9:58] And one interesting thing I see with [10:01] with agents and all of you will be [10:02] seeing it as the feedback loop is [10:04] faster, right? You tell it do this and [10:06] it comes back especially some models [10:07] like Claude code are very good at doing [10:09] that. [10:10] And then you start to get really tired [10:12] cuz and using your terminology like the [10:14] cognitive load increases by faster [10:17] feedback loops. And it seems so [10:19] counterintuitive because until before AI [10:21] we're always we're all about iteration [10:23] fast feedback loops. We we we were never [10:25] ever close to having these fast feedback [10:26] loops. So what what what is happening? [10:28] Is this a not good? Is this a not bad? [10:30] Is it Is it good that we're having [10:32] faster feedback loops but is it bad that [10:34] we're having more cognitive load or how [10:36] are you like it it feels like such a [10:37] contradiction. [10:39] I think it's just different, right? So [10:41] fast feedback loops were good before [10:43] because if I for example if I had a [10:44] question about a library and someone [10:45] could get back to me then then I could [10:47] continue on, right? Like there was a bit [10:48] of a uh [10:50] pause but I kept going. Well, now I'm [10:52] getting feedback so quickly that I'm [10:55] having to sometimes rebuild my mental [10:57] model dozens of times in like a [11:00] 30-minute period. And so it's not just [11:02] it getting fast feedback is good but if [11:04] it's faster than I know how to keep up [11:06] with or if it's interrupting because you [11:08] know sometimes they just want to inject [11:10] text when I am not ready for them to do [11:13] that completion. [11:14] And so you know I think some of that is [11:17] you know sometimes I'll just turn it off [11:19] because I just like need to write for a [11:21] second and then I'll let it review. So [11:22] it's I will say right now like a lot of [11:24] this is kind of an open question. Peop- [11:26] people are starting to look at it but [11:27] also what the environments were like 6 [11:30] months ago was very different than what [11:32] they were like now. So, this is kind of [11:33] evolving. [11:34] It's interesting when you said like you [11:35] turn it off cuz I was talking with [11:37] Mitchell Hashimoto [11:39] founder of HashiCorp about a week ago [11:41] and he was telling me that his workflow [11:42] is he has an agent always side by side [11:44] on the side that usually runs, but he [11:46] turned off all notifications because he [11:48] only wants to go when he is ready. And [11:50] he kicks it off with something and he [11:51] doesn't care when it finishes. And I [11:53] feel we might be like people might be [11:55] starting to discover their working style [11:58] on on what works and what doesn't. [12:00] But speaking of flow state, in in you [12:03] know like being in the flow it it used [12:05] to be amazing as an engineer I I used to [12:07] be really efficient in the flow. And now [12:08] with with AI you can also kind of get in [12:10] the flow maybe a little bit easier. [12:12] In your book you did mention something [12:14] interesting and this is about the [12:14] tooling, but you said that flow state [12:16] does not only depend on tooling. You [12:18] specifically said how things like [12:20] psychological safety, project ownership, [12:23] how technical decisions, how how much [12:26] autonomy you have, all those depend. How [12:29] do you see this changing with AI where [12:31] like the tooling seems to be really good [12:32] at getting in the flow, but could could [12:34] we see that people are actually still [12:35] struggling to get into the flow because [12:37] they're lacking a lot of those things? [12:39] Uh well, tech is easy, people are hard. [12:43] And so, you know, sometimes getting the [12:45] flow really is about understanding what [12:47] I'm doing, having very clear direction [12:49] and goals and and knowing what my what [12:51] my work is doing. So, it's well scoped, [12:53] but I also not just have a well scoped [12:56] feature or something, but I I know what [12:58] the purpose of it is so that I can make [12:59] informed decisions. Some of it is having [13:01] that psychological safety so that I know [13:03] that I can take a risk on something or I [13:06] can ask someone on my team. [13:08] And [13:09] you know, Kent mentioned when we he was [13:11] calling AI the genies, when we're [13:12] working with the genie, that's not the [13:14] same thing. We may have a handful of [13:15] genies, but that's different from having [13:16] a handful of friends, right? In part [13:18] because the energy's different, the [13:20] conversations are different. Also, they [13:22] just agree with us constantly. [13:25] I'm always so smart and I'm like I know [13:27] that was dumb. I know that was very [13:30] dumb. And so and I will say I do my best [13:32] work. Like I [13:34] I can't think of any [13:36] paper is one example, paper or book I've [13:38] written on my own because many times I [13:40] get them started and I'll write most of [13:41] it and then I'm like, I really need [13:43] someone to tell me like where a hole is, [13:45] where am I dumb, what am I missing, what [13:48] makes perfect sense in my head but does [13:50] not make sense to them when I say it. [13:52] And like [13:53] our AI tools and agents just aren't [13:55] there yet. Sometimes they guess really [13:56] well and sometimes they guess in a [13:58] completely orthogonal direction. But on [14:00] that one, do you want to tell the story [14:02] about the Frictionless, the book, when [14:03] you started writing it and then [14:05] you you went back and I think you [14:07] deleted a good part of it, right? [14:09] Listen, I was a software engineer for [14:11] years and then I was a researcher and I [14:14] was writing a bunch. Researchers write a [14:16] very particular way. There's a lot of [14:18] detail, there's a lot of background and [14:21] on page like 105 you get to the point. [14:26] And so I had started it, I was maybe [14:28] working with someone, like we kind of [14:29] chatted about it, but I get through this [14:32] whole section of the book and I realize [14:33] there's I've created several chapters of [14:37] basically like how to do research when [14:39] you're not a researcher. Like how to [14:41] write good survey questions, how to talk [14:42] to people so you understand. It was [14:44] incredibly like detailed and easy to [14:46] understand and 100 pages that no one [14:49] needs to read ever. [14:50] No one is going to read this and so I [14:52] just like tossed it and reached out to [14:54] Abby and I was like, do you want to [14:55] write this book? I think I have an idea [14:57] of the direction I'm going. Also, tell [14:58] me if I get in a rabbit hole. [15:00] Cuz it made sense and it was right. [15:02] Also, no one's going to no one wants to [15:03] read that. [15:05] And we ended up turning it into [15:06] workbooks in the back which were great [15:07] because then it's like fill in the [15:09] table, check the thing, make it really [15:11] useful and actionable. [15:13] So that [15:14] I I'm not great at I'll That's my [15:16] problem with flow states. I'll get in a [15:18] flow and I'll write for the wrong [15:19] audience or I'll write at the wrong [15:21] altitude. Or I'll code at the wrong like [15:26] level of specificity, especially with [15:27] agents, right? Sometimes I'll just give [15:28] it something broad and like that really [15:29] should have been more detailed, but by [15:31] the time I find that out, we're an hour [15:32] in and [15:34] But I I I wonder if if one takeaway [15:36] might be that effort is not gone wasted, [15:39] right? You spend a lot of time in flow [15:41] state writing, let's say the wrong thing [15:43] and and learning, and then the end [15:44] result was something special, something [15:45] that would have not happened if you [15:47] would have so-called one shot at it. We [15:48] talk about so much of one shotting [15:49] things. [15:51] Do you think like we might have to [15:52] really relearn that effort and and [15:54] wasted energy even as a human when [15:56] agents can do infinite of these things, [15:57] it might be helpful for us? Oh, I agree. [16:00] You know, one is being able to clearly [16:02] articulate the problem or the thesis or [16:04] the idea. [16:06] Without trying, I don't get there. [16:09] Right? Um [16:10] and that's true of so many things. I [16:12] think it's both in terms of like [16:14] learning things and kind of getting your [16:15] hands around them, but one open question [16:17] that I think is really interesting to me [16:18] is back when I was doing more coding, I [16:21] kind of had a feel for the system [16:22] because I was coding it all the time. [16:24] Did I know the system? No, it was huge, [16:26] right? But I knew my kind of core I [16:28] could whiteboard it reasonably well. [16:31] And now we're coding and things are [16:33] changing so rapidly. I think there's a [16:35] really interesting open question around [16:37] how can we help support and build these [16:38] mental models, not just in a way that [16:40] reduce cognitive load or improve flow, [16:41] but help us understand our systems [16:44] whether it's like for me, I'm a visual [16:45] person, so I [16:47] years ago when it was first coming out, [16:48] I was asking it for mermaid diagrams all [16:50] the time. [16:51] Right? Like I I needed to see what it [16:52] kind of I needed my I needed it to [16:55] whiteboard with me. [16:56] And I think that'll be different for for [16:57] everyone else, but without taking that [16:59] time, [17:00] like [17:01] we better our brains just work that way, [17:03] right? Our brains just work that way [17:04] better. [17:05] So we we talk about taking the time and [17:07] then we want to understand it's a long [17:09] long change, but this one's for question [17:11] for everyone in engineering leadership [17:12] position who is being hammered by their [17:14] CEO and board and all of these things [17:16] saying, all right, we're paying a bunch [17:17] of money for this stuff and I already [17:19] see the the naughty [17:20] How do we measure it? And they're going [17:22] to ask you like you all been with this [17:24] excellent conversation with Nicole and [17:26] what did Nicole say? What metrics should [17:28] we measure? [17:30] And like can we actually talk about [17:31] honestly of of like where we are, what [17:34] what can work and how you think about [17:36] this? And you must get this so much. [17:38] That is my job. [17:39] Um it depends. [17:44] It is always it depends. [17:45] Uh we can all go into consulting now and [17:47] just make a ton of money. [17:50] Um [17:51] It it really does though. It depends on [17:53] what question it is you're trying to [17:55] ask. Right? So when someone says am I [17:57] being more productive then I'll say, [17:58] "Well, what do you mean by productive? [18:00] When do I know when I see it? What what [18:02] shape does it take?" Right? Like code [18:04] smells have a thing, productivity smells [18:06] have a thing, right? And sometimes it's [18:08] lines of code or like PRs or something [18:13] and I'm like, "Okay, so what does that [18:14] What do you learn from that?" [18:17] Right? Does that help you [18:20] get a feature out to a customer faster? [18:21] And sometimes they're like, "Well, [18:23] yeah." And I'm like, "Okay, is it the [18:24] right feature? [18:26] Do we know it's the right feature?" And [18:27] and what kind of part of that end-to-end [18:30] process [18:31] are we amplifying? Do you also want more [18:33] ideas and more lines of code and more [18:36] reviews and more [18:38] more all everything? And they're like, [18:40] "Well, no." I'm like, I I'm just asking [18:42] questions. [18:44] Right? And so I think that that can [18:46] help. Now, what are we using to measure [18:49] productivity now? I will say it's [18:50] evolving, right? So uh space framework [18:53] ends up being really helpful. So space [18:55] is satisfaction [18:57] uh how satisfied you are with the thing, [19:00] uh performance, right? What's an [19:01] outcome? There's quality or something. [19:04] Uh activities account. What's the [19:06] anything you can count. Uh C is [19:09] collaboration and communication, which [19:11] can be between people, which we're [19:13] seeing evolving, Uh um or between [19:15] systems. [19:16] Uh and then E is efficiency and flow. [19:18] So, that can be like if we're in a flow, [19:20] or it can be the time, just the time it [19:21] takes to get through the system, right? [19:23] And I know I've heard a couple of people [19:25] say here that, you know, everyone's [19:26] talking about velocity, and they want [19:27] things to be faster, and they care about [19:28] velocity, and I'm like, [19:32] I hear you. [19:33] Yes, that can be good. What are the [19:35] guardrails that you want to put in [19:36] place, right? How do we want to think [19:38] about quality? How do we want to think [19:39] about satisfaction? How do we want to [19:42] think about whatever because [19:45] if we just brute force it, something's [19:48] going to break, right? And And there are [19:50] ways where we can make informed [19:52] decisions. So, I've worked with teams [19:54] who I will say there There was a [19:56] question in one of the other sessions [19:57] about sacrificing quality for speed. [20:00] Some teams can, and but when they do it, [20:03] they're doing it very, very [20:04] intentionally. They don't say they're [20:05] sacrificing quality. They say they're [20:07] making a risk-based decision. [20:09] But, this is fair, though. They're [20:10] running a rapid experiment. They want [20:12] signal really, really quickly, and if [20:14] they can get an experiment out in an [20:16] hour, and they can run it against some [20:18] very small percentage, then they're [20:20] willing to take the risk of lower [20:23] latency or a crash or something for that [20:25] very small percentage, and then they [20:27] back it out, and then they get an [20:28] answer. [20:29] So, like, I think with the right metrics [20:30] in place, [20:32] it really helps us make those risk-based [20:33] decisions versus all fast or all slow. [20:37] And I do still see some teams that are [20:39] like all slow because they they just [20:40] want to pump the brakes. I, you know, [20:41] some some folks in like security. [20:47] Which is understandable, but it's like [20:48] now [20:50] they're kind of on fire, right? Their [20:51] feet are on fire because there's just so [20:53] much to do. [20:55] Well, yeah, especially when the rest of [20:57] the business outside We We talked about [20:58] yesterday we had a small event, and we [21:00] talked about how David Cramer from [21:02] Century was talking about how a lot of [21:05] non-developers are getting access to [21:06] cloud code, and they're loving it and [21:07] they're so productive and oh oh this [21:10] might have been actually someone from a [21:11] larger publicly traded company which is [21:13] I I won't name them but one of the [21:15] business developers like created this [21:16] like awesome tool to I think look at [21:18] sales proxies and all that and then [21:20] accidentally made it available for the [21:21] whole world. [21:23] And they caught it in time but now now [21:24] there's a lot of those folks so and and [21:26] I think David Kramer from Century was [21:28] saying like yeah like we we have this [21:29] like annual training where developers go [21:31] and they go kind of a yawn but we will [21:33] need to make this a lot more interactive [21:35] and engaging and everyone in the [21:36] business will have to go. So like [21:37] there's going to be this fun challenge. [21:39] So now it sounds like it's a good time [21:40] to be in security. [21:42] It really is. Well and because now [21:44] there's also kind of evolving I don't [21:46] want to say evolving definitions of [21:47] security right? Like something's kind of [21:48] secure kind of not but what are the [21:50] signals that we're looking for? What are [21:51] the levels of security that are [21:52] important? There are even some good [21:54] questions around you know with some of [21:56] the regulations in certain countries you [21:58] had to have at least two people review [22:00] the code before it can deploy. What does [22:03] that mean? Right? Are there ways that we [22:04] can revisit some of that now and there [22:07] were some improvements made over the [22:08] last changes improvements um over the [22:11] last decade or two so that [22:13] if you passed a set of automated checks [22:15] and tests and that would count as one [22:17] person. Right? Well now it's two. Well [22:18] what if what happens when we have agents [22:20] now? Right? And so I think some of this [22:21] will be important for us to kind of [22:23] discover and think about really creative [22:25] ways to solve the problem in ways that [22:27] are meaningfully [22:29] consistent and also educate the rest of [22:32] not just the industry but regulatory [22:34] fields right? [22:38] Today [22:39] if you're a VP engineering sitting in [22:40] this this group and you are in the [22:42] process of rolling out all these AI [22:44] agents from cloth code it might be Codex [22:45] it might be other vendors [22:48] we we mentioned the importance of [22:50] measuring things. What would your [22:51] suggestion be specific things that you [22:53] can and probably it's not harmful it's [22:55] probably helpful to measure already at a [22:56] tactical level and how would you come [22:58] across how would you get the strategy of [23:00] what to measure so you're actually you [23:03] have the right data, you're you're not [23:05] you're thinking about like not [23:06] necessarily invading too much of [23:07] developer privacy and not collecting [23:09] junk data. [23:11] It depends. [23:12] Um a lot of it kind of so I I will say I [23:15] tend to start with adoption. I am not a [23:17] fan of an adoption metric. I don't like [23:19] it, but also devs are like a gloriously [23:22] cranky bunch. [23:24] We are not going to use tools that are [23:26] awful unless we absolutely like if it's [23:28] the only option, there's almost no other [23:30] other option. I'm going to sound old [23:31] when I say this, but like I one time had [23:33] a company tell me, "Oh, well, they have [23:34] to use that CI/CD system." I'm like [23:36] 20 bucks, they're just spinning up [23:37] Jenkins. [23:39] And they were, right? And so I think [23:41] adoption can give us some early signals [23:45] in part to satisfaction. [23:47] Because if a tool is awful, then they [23:49] won't use it. And if we aren't engaging [23:51] with the tool, so then we can look at [23:52] engagement. If we're not engaging with [23:54] it, then we can't understand, right? [23:56] Like we don't know what the capabilities [23:57] are, we don't know what like how to kick [23:59] the sides. Um [24:01] you know, we might love it immediately [24:03] and decide it's amazing and then later [24:04] find out it what its weaknesses are. We [24:07] might hate it and never go back, but I [24:08] think that can help. Engagement is [24:09] another one, which is [24:11] how much are people using it and for [24:13] what kind of tasks? And so there's some [24:15] tooling that [24:17] uh and I know earlier studies found [24:18] that, you know, for fairly [24:19] straightforward work, it gets used quite [24:21] often, right? And so we can also watch [24:22] how people are kind of using that. Now, [24:24] I'll come back to it depends, right? [24:26] What is it that you're going for is a [24:28] hypothetical VP of engineering, right? [24:29] Do you want people using it? [24:31] Do you want them to get faster cuz [24:34] everyone talks about faster, right? And [24:35] then what do you mean by faster? Is it [24:37] the inner loop coding part? Is it [24:38] features end to end? Because then you [24:40] have to take a much more holistic look [24:42] at the whole system. Um especially if [24:44] we're [24:45] talking about some like magical agentic [24:47] future where they're all self-driving. [24:49] But that's that's another metrics [24:52] rant. [24:53] And [24:54] outside of just measuring, one thing [24:56] that I heard is an interesting approach [24:58] is giving explicit permission. [25:02] Rajeev Rajan, Atlassian's CISO, who will [25:04] be our our speaker in the next one, he [25:06] at Atlassian, he sent a message telling [25:08] to everyone, [25:10] "For 10% of your time, you have my [25:11] explicit permission to experiment with [25:13] these systems and just see how they [25:15] work." [25:16] How do you see these kind of approaches, [25:19] which feels a little bit top-down, but [25:21] it also, I guess, creates a bit more [25:22] safe space? Do you see this being useful [25:25] in general for new technology or [25:27] especially right now? [25:29] It's [25:31] I think it's important in general, [25:32] right? It's basically like comms and [25:34] change management. It's like the really [25:35] old-school stuff. I think it's [25:37] especially important now though, because [25:38] there's so much fear and risk and [25:40] unknown around using AI tools. Will I be [25:43] fired for using them? What if I make a [25:44] mistake by using them? And so, [25:47] um I'm seeing across at least a handful [25:49] of companies that explicit exec [25:51] sponsorship makes a huge difference in [25:54] not just using them, but trying new [25:56] things and feeling safe to fail within, [26:00] you know, kind of guardrails. And I [26:01] know, you know, for years there have [26:02] been places where like if you take down [26:03] all of prod, you get some kind of prize. [26:07] Without taking that to its extreme, that [26:09] can also be helpful because they're [26:10] helping pressure test the systems that [26:12] we work in right now. [26:15] In your book, which is about, again, [26:17] removing friction, having a way to like [26:21] move better, faster, etc. In the in [26:23] towards the end, there's a whole chapter [26:25] on [26:26] sup- um on self-support. On [26:30] the chapter is called support yourself [26:31] through challenging work. Can you talk [26:33] us tell us about why you wrote a whole [26:35] section on it and just advice on how [26:38] folks can support themselves, how you [26:41] see either you're supporting yourself or [26:43] how you see peers getting through this [26:45] like pretty intense time? Yeah. So, the [26:48] context of that last section was uh [26:50] supporting organizations through change, [26:52] supporting your teams through change, [26:54] and supporting yourself. And it was [26:55] interesting because when I had been [26:58] I interviewed like a handful of many [27:00] several handfuls of engineering leaders [27:01] as we were talking about some of this, [27:02] and more than a few of them said it was [27:05] really important for them to [27:06] not just support their teams, you know, [27:08] provide executive formal support for [27:10] using new tools and systems, but also [27:12] themselves because [27:14] anytime you're going through any kind of [27:16] change, whether you're, you know, [27:17] kicking off a brand new DevEx initiative [27:19] or you're rolling out AI, [27:22] especially now when everything is so [27:24] new, [27:25] there's a lot that's unknown there. [27:27] These are really hard problems, right? [27:29] And so, having a couple folks that you [27:31] can talk to, your own, uh, I want to say [27:32] Rose uh, Whitley said, [27:35] uh, [27:36] you should have your own board of [27:37] directors. [27:38] Because then we can bounce ideas past [27:40] people. We can safely say [27:43] what is happening. I have to go. I have [27:46] to go to an exec review, and I need to [27:48] have an opinion, and like, I understand [27:49] half of this. Like, can you talk this [27:53] this through with me? And I think that [27:54] also helps with burnout, right? Because [27:57] burnout, we know, you know, Christine [27:58] Maslach has done some some really great [28:00] work where [28:02] um, burnout is a combination of things. [28:05] It's working too hard, right? But that [28:07] actually isn't burnout. That's just like [28:09] getting tired. [28:10] Another piece that's super critical to [28:12] burnout is not having your values [28:14] aligned. [28:15] And so, sometimes I have found that [28:17] talking through people and and others [28:18] who told me the same is kind of [28:20] understanding where your values are, if [28:22] your values align, and then if they [28:24] don't. And many times they found that [28:25] they did align, and it sort of like [28:26] relieved some of that pressure that they [28:28] were under. [28:31] And finally, [28:32] looking ahead, um, [28:34] in two to three years' time, how would [28:36] you envision a [28:38] more or less frictionless organization [28:40] operating? A a company where like takes [28:42] this very seriously. They are adopting [28:44] AI tools. They're like, all right, let's [28:46] remove the friction points. How how [28:47] would that look like? And if you're [28:49] sitting in this room today and you're [28:51] you want to walk away and you want to [28:52] start doing something this week, where [28:54] would you start? [28:55] On top of a course, getting the book and [28:57] reading it. [28:59] Uh workbooks are also free online. You [29:01] can go find those. [29:02] Um [29:04] So, a couple things for the kind of [29:06] frictionless future. I'm I'm a metrics [29:08] person. So, my answer is going to be [29:10] about data. Um but I think [29:13] you know, I've I've been having [29:14] conversations with folks for a handful [29:16] of months now around if we think there's [29:17] this future world where agents can [29:19] self-drive and self-improve and they can [29:21] do all the things and our organizations [29:23] run better. For that to be true, right? [29:25] So, that's going to be true, maybe. [29:27] Maybe not, but it's a stretch. For that [29:29] to be true, [29:31] agents need to be able to see and [29:33] understand the system. [29:34] And agents need to be able to improve [29:36] the things that need fixed. For that to [29:38] be true, [29:39] humans need to be able to see and [29:40] understand the system [29:41] and then take action to fix it. Uh and [29:44] for that to be true, we got to see the [29:45] system. [29:46] Right? Particularly when when we're [29:48] moving really, really quickly. Right [29:49] now, [29:51] humans are a stopgap, right? We'll talk [29:53] to people, we understand the system. [29:55] I I just know that when there's a [29:57] problem over here, it's like usually [29:59] about the build, [30:01] right? [30:03] Agents aren't going to be able to do [30:04] that or if they are, like, we probably [30:05] don't want that. And so, how can we [30:07] think about ways to easily and cheaply [30:10] surface some of the signals that can [30:11] help us make decisions? And it doesn't [30:13] have to be super heavyweight, although [30:15] like agents can also probably help us [30:17] build some instrumentation, that's [30:18] pretty good, right? So, how can we how [30:21] can we think about ways to first of all, [30:23] identify what are the touchpoints that [30:24] we care about? Where are the signals [30:25] that we want to see? How can we make it [30:27] cheap and easy to get a hold of those? [30:29] And then how can we kind of sense make [30:31] around them and and realize that's going [30:32] to change, right? Like there's several [30:34] phases in like writing software. There's [30:36] like having the idea and coming up with [30:38] the design and then coding it and then [30:41] right now, that whole front end has been [30:42] like kind of smooshed because many times [30:45] we can just like prototype really really [30:47] rapidly and kind of [30:49] solidify some of what we're thinking in [30:51] terms of like ideas and coding. [30:54] So [30:55] I [30:56] fully expect that part of the outer loop [30:58] is just going to be collapsed as well, [31:00] right? Because we'll find more efficient [31:01] ways to do that. [31:03] But it's going to be helpful if in the [31:04] interim we know where some of those [31:05] touch points are, right? Like what are [31:06] we looking for? What are the quality [31:08] gates? What are the signals that show us [31:10] something is working well or not? And [31:12] then if we collapse, then where do those [31:14] signals shift to? Or do they get to [31:16] disappear? [31:18] Yeah, and it feels to me that with so [31:19] much change coming, one thing that feels [31:21] really important to me that again it was [31:23] in the book and we just talked about it [31:24] is having this personal board of [31:25] directors, finding peers who ideally [31:27] work at different companies. You might [31:29] meet some people here, you might already [31:30] know them, reach out to them, and it [31:32] sounds like it's a time where everyone [31:33] will be happy to get together to have [31:35] coffee, create a WhatsApp group or or [31:37] just just a group message group with a [31:38] few of you, and you talk, I'm doing [31:40] this, I'm seeing this, I'm doing this, [31:41] I'm seeing this because it seems like [31:42] the only certain thing is it will change [31:44] and it will depend what works for you. [31:46] So if you get like-minded people in [31:47] similar industries, the it depends will [31:50] probably more similar to a lot of you, [31:52] right? Yeah. Um and I found that's to be [31:54] some of the most helpful and the most [31:55] beneficial for me is, you know, can I [31:57] bounce an idea off someone? Is the way [31:59] I'm explaining it making sense? [32:02] Uh are the things that I'm seeing [32:03] similar to the things that you're [32:04] saying? And if yes, what could that [32:06] mean? And if no, is it actually [32:08] different or are we just using different [32:09] words? Right? And so that, I think [32:11] especially when we're in a time of [32:13] change at all, but especially this [32:15] rapid, it's super super helpful. And I [32:18] also just keep I've got like the back [32:20] channel, right? So sometimes it's [32:21] talking to someone, and sometimes it's [32:23] just like popping a question at a back [32:24] channel with a handful of folks that you [32:26] know and respect and you feel safe with.