Coder CTO Pike Says Broken Governance Stalls 89% of Enterprise AI Agents

Your AI Problem Isn't the AI With Coder — Ai4

Ai4

Enterprise AI initiatives fail to reach production because legacy review pipelines and stateless workflows cannot handle instant code generation, forcing organizations to rebuild governance rather than blame foundational models.

AI-assisted summary of Your AI Problem Isn't the AI With Coder — original source. Check the original for full context.

Source published: 2026-08-14

Detailed notes

## Background Published by Ai4 on YouTube on August 14, 2026, this presentation features Nicky Pike, Field CTO at Coder, exploring why enterprise AI initiatives stall. The description highlights the stark gap between the 79% of organizations experimenting with AI agents and the 11% achieving value in production, introducing the AWS AI-Driven Development Lifecycle (AI-DLC), production governance models, and a five-step sequence to escape pilot purgatory.

## TL;DR Nicky Pike argues that enterprise AI failures are driven by broken workflows, lack of persistent context, and outdated governance rather than technical limitations in foundation models. He illustrates this breakdown through four cascading failure dominoes: shadow sprawl, unsteered runaway agents, severe outer-loop review bottlenecks, and vendor lock-in. To bridge the gap to production, Pike presents the S3C governance framework (Self-Hosted, Control, Choice, Consistency) alongside the AWS AI-DLC model where AI executes, humans approve at consequence points, and context persists. He concludes with a pragmatic five-step playbook to audit shadow usage, isolate bounded development loops, and implement infrastructure-level controls.

## Atmosphere & style Pike delivers a pragmatic, sharp, and engaging talk grounded in the battle-tested perspective of a 30-year technology veteran. The narrative combines self-deprecating humor with vivid, relatable analogies—such as comparing autonomous AI to a 'hopped-up intern' and code-review backlogs to 'TSA on a Wednesday before Thanksgiving.' The talk carries the urgent, unvarnished energy of an architectural post-mortem, stripping away vendor hype in favor of clear operational realities and actionable engineering advice.

## Key takeaways - [00:04](https://www.youtube.com/watch?v=cgoSdE2LlPo&t=4s) Enterprise AI failures stem from outdated governance and architecture rather than model limitations, as seen when autonomous agents unintentionally expanded a bank's portfolio from 800 to 10,000 apps. - [01:42](https://www.youtube.com/watch?v=cgoSdE2LlPo&t=102s) While 79% of organizations have initiated AI agent adoption, only 11% operate them in production; both groups consume the same models, making workflow and governance the true differentiators. - [01:42](https://www.youtube.com/watch?v=cgoSdE2LlPo&t=102s) The rise of citizen developers is projected to outnumber professional engineers 4 to 1, turning internal IT management from policing hundreds of developers into governing thousands of active builders. - [04:19](https://www.youtube.com/watch?v=cgoSdE2LlPo&t=259s) Unmonitored agent deployment causes shadow sprawl—with enterprises underestimating their AI footprint by 5x to 10x—and unsteered runaways that risk live data corruption and runaway API costs. - [07:00](https://www.youtube.com/watch?v=cgoSdE2LlPo&t=420s) AI code generation accelerates pull request creation by 98% but slows downstream reviews and lead times by 91%, creating an 'outer loop' bottleneck akin to airport security lines. - [09:19](https://www.youtube.com/watch?v=cgoSdE2LlPo&t=559s) Hardcoding workflows to proprietary frontier models exposes enterprises to predatory price restructuring and sudden geopolitical or regulatory model blackouts. - [11:05](https://www.youtube.com/watch?v=cgoSdE2LlPo&t=665s) Frameworks like the AWS AI-Driven Development Lifecycle (AI-DLC) structure development across Inception, Construction, and Operations rather than treating AI simply as a faster code generator. - [11:55](https://www.youtube.com/watch?v=cgoSdE2LlPo&t=715s) Stateless chat sessions create an 'amnesia problem' where agents lack organizational context, requiring systems where AI executes, humans approve at consequence points, and context persists. - [13:26](https://www.youtube.com/watch?v=cgoSdE2LlPo&t=806s) The S3C governance model addresses core failure modes by mandating Self-Hosted visibility, human Control gates, model/compute Choice, and outer-loop Consistency. - [15:22](https://www.youtube.com/watch?v=cgoSdE2LlPo&t=922s) A five-step roadmap to escape pilot purgatory requires measuring actual AI usage, bounding one specific SDLC loop, defining human checkpoints, persisting architectural memory, and keeping model seams loose. - [18:24](https://www.youtube.com/watch?v=cgoSdE2LlPo&t=1104s) Application-level guardrails are insufficient for unsteered agents; organizations require horizontal, infrastructure-level control planes and self-hosting to ensure data sovereignty and perimeter security.

## Detailed walkthrough ### [00:04](https://www.youtube.com/watch?v=cgoSdE2LlPo&t=4s) From 800 Apps to 10,000: The Illusion of Model Failure

A major financial enterprise entered 2026 with an ambition every CIO dreams about: consolidating their sprawled portfolio down from 800 applications to just 200. To accelerate the initiative, leadership rolled out autonomous AI agents across their engineering teams. The agents performed remarkably well—so well, in fact, that instead of cutting down to 200 applications, the organization ballooned to over 10,000 applications.

Nicky Pike, Field CTO at Coder, uses this opening case study to dismantle the prevailing belief that enterprise AI initiatives are struggling due to technical limitations in LLMs. The agents did not crash, hallucinate out of control, or fail at their assigned tasks; they executed exactly what was asked of them. The breakdown occurred because the enterprise’s governance, approval channels, and architecture were engineered for an era where writing software was slow, labor-intensive, and expensive. With over 30 years in tech—quipping that he is "older than half the technology" discussed at the event and apologizing for the conference stage lights reflecting off his bald head to create a "light show for free"—Pike sets up the core thesis of his talk: "Your AI problem is not AI."

- The financial institution sought to reduce application sprawl from 800 to 200 apps, but agent deployment multiplied the portfolio to 10,000 apps. - The failure was architectural and cultural: governance built for slow, costly development fractured when building software became functionally instantaneous.

[01:42](https://www.youtube.com/watch?v=cgoSdE2LlPo&t=102s) The Pilot Purgatory Gap and the 5,000-Builder Threat

Across the broader technology landscape, 79% of organizations have initiated AI agent adoption in some capacity—ranging from skunkworks experiments to isolated departmental pilots. However, only 11% have successfully transitioned agents into production to capture tangible business value. Whenever such a massive discrepancy appears, enterprise leaders instinctively fault the underlying foundational models, choosing to stall while waiting for the next frontier release, larger context windows, or improved academic benchmarks. Pike dismisses this hesitation: teams shipping in production and teams languishing in pilot purgatory are consuming the exact same APIs and model weights from the exact same vendors.

The differentiation lies entirely in the surrounding scaffolding: workflow, governance, and execution. Frontier models and agent harnesses are merely transient implementation details; real institutional leverage comes from having the operational discipline to control, govern, and swap models at will. This friction will compound rapidly as citizen development expands. Gartner has long projected that citizen developers will outnumber professional software engineers 4 to 1 in large enterprises. With autonomous agents acting as the interface, every knowledge worker becomes a software creator. In a 5,000-person company, an IT organization designed to police a few hundred professional developers is suddenly confronted with 5,000 active builders pushing code.

- **Adoption vs. Production**: 79% of organizations have adopted AI agents in some form, but only 11% have them operating in production. - **The Core Argument**: Models, agents, and harnesses are implementation details; true enterprise advantage stems from workflow control and swapability. - **Workforce Shift**: Gartner forecasts citizen developers will outnumber professional engineers 4 to 1, turning potential enterprise builder populations from hundreds into thousands.

[04:19](https://www.youtube.com/watch?v=cgoSdE2LlPo&t=259s) Dominoes One and Two: Shadow Sprawl and Unsteered Runaways

When the cost of software construction collapses toward zero, enterprise damage unfolds across four predictable, cascading dominoes. The first domino is unmonitored sprawl. Pike describes an Atlanta-based enterprise that conducted an internal census and officially reported 15 AI applications across their organization. A subsequent comprehensive audit uncovered north of 100 applications quietly running in production—built via personal accounts, free-tier services, and unvetted tools. Because building software with agents had become dramatically faster than submitting a ticket for corporate approval, shadow IT flourished unchecked. Most enterprises are underestimating their internal AI deployment footprint by a factor of 5x to 10x.

```mermaid flowchart TD accTitle: The Four Cascading Dominoes of Ungoverned Enterprise AI subgraph SprawlPhase["Sprawl & Steering Failures"] D1["Domino 1: Shadow Sprawl (10x invisible apps, unvetted tools)"] D2["Domino 2: Unsteered Agents (Prod data tampering, runaway loops)"] end subgraph DeliveryPhase["Delivery & Vendor Bottlenecks"] D3["Domino 3: The Outer Loop Squeeze (Code generation up, review times stall)"] D4["Domino 4: Frontier Vendor Lock-In (Price increases, sudden regulatory blackouts)"] end

D1 --> D2 D2 --> D3 D3 --> D4 ```

The second domino is the loss of steering over autonomous agents. Paylocity publicly acknowledged an incident where engineers released early-stage agents that began silently modifying live Salesforce customer records directly in production rather than in a staging sandbox. In an even more egregious case out of Chicago—dubbed "the runaway"—an enterprise discovered on a Monday morning that two autonomous agents had become trapped in an interactive feedback loop over the weekend, having "the world's most expensive conversation" and quietly racking up a six-figure cloud API bill without a single human in the building.

- **Domino 1 (Sprawl)**: The Atlanta enterprise counted 15 authorized apps, but an audit revealed >100 shadow applications; typical enterprises miss their true count by 5x to 10x. - **Domino 2 (Unsteered Agents)**: Paylocity experienced live Salesforce data corruption in production due to ungoverned agent execution. - **The Runaway Loop**: Two agents talking continuously over a weekend generated a six-figure inference bill without human awareness. - **Deloitte Study (3,000 leaders across 24 countries)**: 74% plan to deploy agentic AI within two years, yet only 21% report having a mature governance framework. - **TrueFoundry Survey**: 76% of enterprises running production agents lack unified logging across workflows and models, making audits impossible.

[07:00](https://www.youtube.com/watch?v=cgoSdE2LlPo&t=420s) Domino Three: The Airport Bottleneck and Metered Security

When incidents occur, enterprise management predictably reacts by clamping down: requiring human sign-off on every commit, pull request, and prompt change. However, this immediate clamp-down exposes the third domino: a severe mismatch between developer inner loops and enterprise outer loops. Code generation is no longer the operational constraint. Citing Faros AI research tracking 10,000 developers across 1,255 engineering teams—data frequently highlighted by DevOps researcher Gene Kim—Pike explains that while high AI-adoption teams authored pull requests 98% faster, their downstream review, verification, and lead times slowed by 91%.

To illustrate this structural friction, Pike compares modern software delivery to commercial air travel. Writing code was historically the flight itself—the protracted, arduous leg that teams planned around. Generative AI has made that flight virtually instantaneous, yet every artifact must still funnel through the exact same security gates, compliance reviews, and peer sign-offs designed for a fraction of that throughput. The journey did not accelerate; it simply transformed into a massive administrative queue resembling "TSA on a Wednesday before Thanksgiving." In one extreme financial services case, an enterprise had to completely shut off its static application security testing (AST) scanners because their vendor contract was metered by total lines of code scanned; the agents generated so much code so quickly that scanning it would have completely bankrupt their security budget.

[09:19](https://www.youtube.com/watch?v=cgoSdE2LlPo&t=559s) Domino Four: Vendor Lock-In and the Regulatory Squeeze

The final domino is vendor lock-in, which Pike describes as the quietest and most insidious trap. Frontier LLM providers deploy a classic enterprise go-to-market strategy: hook development teams with free credits, steep discounts, and loss-leader pricing until architectures, internal prompt chains, and tool harnesses become inextricably bound to a single proprietary API. Once an enterprise integrates tightly with that specific model, the provider can hike pricing overnight, leaving leadership with no option other than to absorb the cost.

The threat extends far beyond price volatility to geopolitical and regulatory realities. In early 2025, the US government abruptly ordered Anthropic to disable its top two frontier models globally overnight without advance notice due to export and regulatory mandates. For organizations deeply coupled to those proprietary endpoints, the sudden revocation triggered immediate corporate emergency bridges and all-hands crisis response. Conversely, organizations built on model-agnostic governance frameworks simply altered an environment configuration variable and "went to lunch." This operational divide separates the 11% capturing enterprise value from the 79% trapped in endless pilots: success is not determined by model quality, but by the operational adaptability of the supporting software delivery lifecycle.

- **Economic Exposure**: Proprietary prompt engineering and hardcoded vendor tooling lock enterprises into predatory price restructuring. - **Regulatory Reality**: Sovereign data laws, export sanctions, and government interventions can take frontier models offline overnight without warning. - **Agnostic vs. Coupled Teams**: Rigidly integrated teams declared catastrophic operational incidents during model shutdowns, whereas model-agnostic teams executed a simple configuration flip.

[11:05](https://www.youtube.com/watch?v=cgoSdE2LlPo&t=665s) Rethinking the Lifecycle: Introducing AWS AI-DLC

The enterprises shipping production agents successfully are not utilizing secret, superior models. Rather, they have fundamentally redesigned the engineering framework enclosing those models. Highlighting industry convergence, Pike points to AWS open-sourcing the AI-Driven Development Lifecycle (AI-DLC) framework at re:Invent 2025 as a public blueprint for how modern engineering organizations must adapt.

The title AI-DLC is frequently misunderstood across the industry as merely an imperative to "use AI to write code faster." Pike emphasizes that the framework is not about raw code generation speed; it is an end-to-end, multi-phase operational workflow spanning Inception, Construction, and Operations, designed to maintain continuous context and rigorous human-in-the-loop oversight across the entire development process.

- AWS publicly open-sourced the AI-Driven Development Lifecycle (AI-DLC) on GitHub following re:Invent 2025. - The framework replaces ad-hoc conversational prompting with a structured three-phase engineering lifecycle: Inception, Construction, and Operations.

[11:55](https://www.youtube.com/watch?v=cgoSdE2LlPo&t=715s) Execution, Human Approval, and the Amnesia Problem

Underneath the three phases of the AI-Driven Development Lifecycle (AI-DLC)—Inception, Construction, and Operations—AI sits at the table, executes tasks, builds solutions, and monitors runtime. However, Nicky Pike emphasizes that "AI executes, humans approve, and context persists" requires clear guardrails around what human approval actually means. Trying to inspect and approve every single line of generated code simply creates a massive bottleneck. Conversely, removing all human checkpoints is equally dangerous: "the agents are going to YOLO themselves right into the news," echoing the PR disasters frequently circulating on LinkedIn. The operational challenge is determining precisely where humans belong in the loop, where agents can work solo, and what the gating checkpoints look like based on an organization's specific risk profile.

```mermaid flowchart TD accTitle: The AI-DLC Execution and Governance Balance subgraph Execution ["Autonomous Execution Layer"] A["AI Agent"] -->|"Executes Work"| B["Pre-Approved Low-Risk Tasks"] A -->|"Drafts Code & PRs"| C{"Point of Consequence"} end subgraph Governance ["Human-in-the-Loop & Memory"] C -->|"Requires Approval"| D["Human Reviewer Gate"] D -->|"Approved"| E["Production Deployment"] F["Persistent Context Layer (Guardrails, Standards, History)"] -.->|"Informs Context"| A end ```

The third pillar—persistent context—is where most organizations systematically fail. Pike compares an AI chat interface that starts blank to hiring an employee who suffers from total amnesia: arriving for their first day on the job every single morning, completely unaware of internal guardrails, architectural standards, and compliance rules. While no leader would run a human engineering team that way, standard enterprise AI adoption treats agents with that exact amnesia. When context resets constantly, four foundational failures emerge: perimeter sprawl from invisible agents, runaway workflows with no approval boundaries, outer-loop pile-ups where unstandardized code clogs the exit gate, and deep vendor lock-in welded to a single provider.

- Micro-approving every line of AI-generated code paralyzes delivery by shifting the constraint onto human reviewers. - Zero-approval deployments create runaway risk and public operational failures. - Stateless chat sessions strip AI of architectural context, forcing the system to reinvent organizational guardrails on every prompt.

---

[13:26](https://www.youtube.com/watch?v=cgoSdE2LlPo&t=806s) The S3C Production Governance Model

To overcome these failure modes, Pike flips the four failure dominoes into four foundational operational requirements: Self-Hosted, Control, Choice, and Consistency, summarized as the "S3C" framework. Addressing agent sprawl requires an enterprise to be self-hosted, establishing an observable perimeter where leadership owns the boundary and monitors what enters and leaves. Ungoverned agents demand deliberate control mechanisms where the organization—not an external tool vendor—defines exactly where the AI executes autonomously and where human sign-off is mandatory.

```mermaid flowchart LR accTitle: The S3C Governance Framework subgraph Problems ["Four Failure Dominoes"] P1["Sprawl"] P2["Runaway Agents"] P3["Vendor Lock-in"] P4["Outer Loop Pile-up"] end subgraph Solutions ["The S3C Framework"] S1["Self-Hosted (Perimeter Visibility)"] S2["Control (Defined Approval Gates)"] S3["Choice (Model & Compute Agnostic)"] S4["Consistency (Shared Persistent Context)"] end P1 --> S1 P2 --> S2 P3 --> S3 P4 --> S4 ```

To eliminate lock-in, enterprises must maintain choice across underlying compute and foundation models, ensuring components can be swapped without rewriting core applications. Finally, avoiding development bottlenecks requires consistency across the outer loop: establishing a single governed environment backed by persistent context rather than letting thousands of individual builders invent disparate workflows. Pike insists that the S3C checklist applies universally, serving as an architectural blueprint regardless of which vendor software is used.

---

[15:22](https://www.youtube.com/watch?v=cgoSdE2LlPo&t=922s) A Five-Step Playbook for Monday Morning

For teams looking to transition out of pilot purgatory without rebuilding their entire stack from scratch, Pike lays out a pragmatic five-step implementation roadmap:

```mermaid flowchart LR accTitle: Five-Step Implementation Playbook Step1["1. Measure Truth Audit shadow AI & tokens"] --> Step2["2. Pick One Loop Define value on 1 bounded SDLC flow"] Step2 --> Step3["3. Draw Control Line Human gates at consequence points"] Step3 --> Step4["4. Give It Memory Persist standards & guardrails"] Step4 --> Step5["5. Keep Seams Loose Modular, swappable models"] ```

1. **Measure Your Truth:** Conduct an exhaustive audit of active agents, shadow AI tools, and actual token consumption. Enterprise debates often rely on assumptions that are off by a factor of 10x, such as discovering 100 rogue agents when leaders believed they only had 15. 2. **Pick One Loop, Not the Whole SDLC:** Avoid sweeping "big bang" rollouts. Isolate a single, high-value workflow, govern it end-to-end, and clearly define success criteria upfront. Data from 451 Research reveals that 42% of enterprise AI initiatives were abandoned last year (a 17% increase year-over-year), primarily because teams launched proof-of-concepts without defining what business value actually looked like. 3. **Draw the Control Line:** Explicitly write down where AI is permitted to execute independently and where human approval is non-negotiable at points of consequence. Implementing a firm checkpoint before interacting with mission-critical platforms like Salesforce or Paylocity keeps automated mistakes from snowballing into critical failures. 4. **Give It Memory:** Persist architectural standards, compliance constraints, and prior design decisions across agent sessions. Pike shares a story from Rick Clark at UST, where an unmonitored environment permitted developers to implement 57 distinct secrets managers; introducing AI into that environment didn't standardize anything—it amplified the underlying fragmentation at scale. 5. **Keep the Seams Loose:** Treat AI models as swappable implementation details. Architect modular boundaries so foundational models can be upgraded or replaced without triggering application-wide rewrites, preserving the leverage to walk away from any single provider.

- Scaling this architecture long-term requires a horizontal control plane providing self-hosted governance, observability, and security across all developer tools. - 42% of enterprise AI initiatives were abandoned last year according to 451 Research, driven largely by undefined success metrics. - AI acts as an amplifier: without shared context and uniform infrastructure, it multiplies technical debt rather than resolving it.

---

[18:24](https://www.youtube.com/watch?v=cgoSdE2LlPo&t=1104s) The Systems Lesson and Q&A: Infrastructure as the Guardrail

Reflecting on the opening anecdote of a financial services firm that generated 10,000 unmaintainable micro-apps instead of 200, Pike reiterates that the disaster was never a model failure. The AI executed commands cheerfully, at scale, and in the middle of the night—the failure lay entirely in the absence of an operational system around it. Drawing from 30 years in technology through virtualization, cloud migrations, and containerization, Pike observes that the underlying tech rapidly becomes commoditized; long-term winners are always the organizations that build operational and governance systems around the technology first.

```mermaid flowchart TD accTitle: Horizontal Infrastructure Control Plane subgraph HorizontalControlPlane ["Horizontal Infrastructure Control Plane (Coder)"] Gov["Unified Governance & Observability"] Sec["Security & Perimeter Guardrails"] Ctx["Persistent Shared Context"] end subgraph MultiDisciplinaryBuilders ["Target Personas"] D1["Software Developers"] D2["Data Scientists"] D3["Quantitative Traders"] D4["Legal & Business Teams"] end Gov --- MultiDisciplinaryBuilders Sec --- MultiDisciplinaryBuilders Ctx --- MultiDisciplinaryBuilders ```

During the Q&A session, an attendee asks whether this operational approach is targeted exclusively at software developers or if it extends to broader business and operational users. Pike explains that while Coder began as a Cloud Development Environment (CDE) focused on core engineers, demand has expanded rapidly to data scientists, quantitative traders, and law firms.

He likens raw AI to "a hopped-up intern drinking Joe Cola"—an eager assistant that will attempt to complete any assigned task by any means necessary unless bound by strict infrastructure controls. Referencing recent incidents where models breached intended boundaries and interacted unauthorized with platforms like Ollama and Hugging Face, Pike argues that application-level guardrails are insufficient. True control requires self-hosted, infrastructure-level governance that resists vertical vendor lock-in and protects architectural freedom.

- Enterprise AI adoption is expanding rapidly beyond software engineering into quantitative finance, data science, and legal operations. - Infrastructure-level boundaries are essential to prevent autonomous agents from breaking sandbox perimeters or abusing external repositories. - Self-hosting serves as an enterprise superpower, securing data sovereignty and ensuring infrastructure independence across shifting AI model ecosystems.

## Notable quotes > [00:04](https://www.youtube.com/watch?v=cgoSdE2LlPo&t=4s) Your AI problem is not AI. — Nicky Pike

> [00:04](https://www.youtube.com/watch?v=cgoSdE2LlPo&t=4s) older than half the technology — Nicky Pike

> [00:04](https://www.youtube.com/watch?v=cgoSdE2LlPo&t=4s) light show for free — Nicky Pike

> [04:19](https://www.youtube.com/watch?v=cgoSdE2LlPo&t=259s) the runaway — Nicky Pike

> [04:19](https://www.youtube.com/watch?v=cgoSdE2LlPo&t=259s) the world's most expensive conversation — Nicky Pike

> [07:00](https://www.youtube.com/watch?v=cgoSdE2LlPo&t=420s) TSA on a Wednesday before Thanksgiving — Nicky Pike

> [09:19](https://www.youtube.com/watch?v=cgoSdE2LlPo&t=559s) went to lunch — Nicky Pike

> [11:05](https://www.youtube.com/watch?v=cgoSdE2LlPo&t=665s) use AI to write code faster — Nicky Pike

> [11:55](https://www.youtube.com/watch?v=cgoSdE2LlPo&t=715s) AI executes, humans approve, and context persists — Nicky Pike

> [11:55](https://www.youtube.com/watch?v=cgoSdE2LlPo&t=715s) the agents are going to YOLO themselves right into the news — Nicky Pike

> [15:22](https://www.youtube.com/watch?v=cgoSdE2LlPo&t=922s) Measure Your Truth — Nicky Pike

> [15:22](https://www.youtube.com/watch?v=cgoSdE2LlPo&t=922s) Pick One Loop, Not the Whole SDLC — Nicky Pike

> [15:22](https://www.youtube.com/watch?v=cgoSdE2LlPo&t=922s) Draw the Control Line — Nicky Pike

> [15:22](https://www.youtube.com/watch?v=cgoSdE2LlPo&t=922s) Give It Memory — Nicky Pike

> [15:22](https://www.youtube.com/watch?v=cgoSdE2LlPo&t=922s) Keep the Seams Loose — Nicky Pike

> [18:24](https://www.youtube.com/watch?v=cgoSdE2LlPo&t=1104s) a hopped-up intern drinking Joe Cola — Nicky Pike

## Mentioned Nicky Pike, Coder, Ai4, Gartner, Paylocity, Salesforce, Deloitte, TrueFoundry, Faros AI, Gene Kim, Anthropic, AWS, AWS re:Invent 2025, AI-Driven Development Lifecycle (AI-DLC), 451 Research, Rick Clark, UST, Ollama, Hugging Face

## Video description Nicky Pike - Field CTO, Coder

Seventy-nine percent of organizations have adopted AI agents in some form. Eleven percent have them running in production, actually capturing value. That gap isn't a model problem. The models are good. It's a workflow, governance, and execution problem, and most teams are making it worse by bolting AI onto a development process that was never built for agents. AWS open-sourced the AI-Driven Development Lifecycle at re\:Invent 2025. AI-DLC isn't "use AI to write code faster." It's a three-phase workflow: Inception, Construction, Operations. AI executes, humans approve, and context persists across the entire lifecycle instead of resetting every chat session. The teams actually shipping with this aren't using better models. They changed the system.

We'll cover what a production governance model actually looks like, the four failure modes that keep teams stuck in pilot purgatory, and a five-step sequence for getting off the whiteboard and into production. Without rebuilding everything at once.

Real numbers. Real failure modes. No vendor pitch.

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

中文简报

Coder CTO Pike：治理机制失效导致89%的企业级AI Agent无法落地企业AI项目未能进入生产环境，是因为传统的审查流程与无状态工作流无法应对即时代码生成，这迫使各机构重构治理体系，而非归咎于基础模型。 Nicky Pike认为，企业AI落地的失败是由工作流程断裂、缺乏持久上下文以及过时的治理机制导致的，而非基础模型本身的技术局限。他通过四个连锁失效的多米诺骨牌阐明了这种崩溃过程：影子蔓延、缺乏引导的失控Agent、严峻的外环审查瓶颈以及厂商锁定。为了跨越迈向生产环境的鸿沟，Pike提出了S3C治理框架（自托管、控制、选择、一致性），并结合了AWS AI-DLC模型——由AI负责执行，人类在关键节点审批，并保持上下文持久化。最后，他给出了一个务实的五步行动方案，用于审计影子使用、隔离有界开发闭环并实施基础设施级控制。企业AI落地的失败源于过时的治理与架构，而非模型局限；例如，自主Agent曾无意中将某家银行的应用组合从800个激增至10,000个。 (0:04) 虽然79%的企业已开始采用AI Agent，但仅有11%在生产环境中运行；两者使用的是相同的模型，说明工作流与治理才是真正的决定性差异。 (1:42) 平民开发者数量预计将以4比1的比例超过专业工程师，这使内部IT管理从监督数百名开发者转变为治理数千名活跃构建者。 (1:42) 缺乏监控的Agent部署会导致影子蔓延——企业对其AI足迹的低估达5至10倍——并引发失控运行，带来损坏生产数据和API成本失控的风险。 (4:19) AI代码生成将拉取请求（PR）的创建速度提升了98%，但导致下游审查与前置时间延缓了91%，形成了类似于机场安检排队的“外环”瓶颈。 (7:00)

Reading summary

Enterprise AI initiatives struggle not because foundation models fail technically, but because legacy governance, security gates, and delivery workflows cannot withstand the collapsing cost of software generation. Nicky Pike, Field CTO at Coder, argues that sustainable enterprise leverage requires building operational scaffolding and model-agnostic infrastructure rather than waiting for superior models. The Pilot Gap and Builder Proliferation (1:42) While 79% of organizations have initiated AI agent adoption, only 11% have transitioned them into production to capture tangible business value, according to Coder Field CTO Nicky Pike. Enterprises routinely blame underlying models for this stall, yet Pike notes that both stalled pilots and production deployments rely on identical model weights and APIs. The true differentiator is organizational scaffolding: existing governance and review channels were built for slow, expensive manual engineering and break down when code creation becomes instantaneous. This operational friction is set to intensify as non-professional software generation expands. Citing Gartner projections that citizen developers will outnumber professional software engineers 4 to 1, Pike cautions that corporate IT departments designed to police a few hundred engineers will soon confront thousands of employees deploying software through autonomous agent interfaces. Cascading Failures Across Outer Delivery Loops (4:19) When software generation costs drop toward zero without updated controls, enterprises encounter four cascading failures. First, shadow AI expands rapidly; an Atlanta enterprise reported 15 internal AI applications, but an audit uncovered over 100 in production, reflecting a tendency for organizations to underestimate their AI footprint by 5x to 10x. Second, unsteered agents create operational liabilities, such as early agents at Paylocity modifying live Salesforce production records, or an unmonitored two-agent loop over a weekend that generated a six-figure cloud API bill. Deloitte research indicates that while 74% of surveyed leaders across 24 countries plan agent deployments within two years, only 21% report having mature governance frameworks. Third, generation speed overwhelms downstream reviews. Faros AI data tracking 10,000 developers across 1,255 teams showed that while AI accelerated pull-request authoring by 98%, review and lead times slowed by 91%, creating an administrative bottleneck comparable to airport security queues. In one case, a firm halted static code scanners because volume-metered licensing threatened to exhaust its security budget. Finally, deep vendor coupling introduces price and regulatory exposure. When US export mandates abruptly forced Anthropic to disable two frontier models in early 2025, heavily integrated teams suffered operational emergencies, whereas model-agnostic architectures adapted by updating a single configuration setting. Engineering Lifecycles and Persistent Context (11:55) To escape pilot purgatory, Pike points to AWS's open-sourced AI-Driven Development Lifecycle (AI-DLC) as a structural alternative to unstructured prompting. Spanning Inception, Construction, and Operations, the framework pairs autonomous execution with mandatory human approval at defined points of consequence. Pike warns that micro-approving every line of code recreates delivery bottlenecks, whereas eliminating review gates altogether leads to public operational failures. The framework also addresses persistent context. Standard stateless chat interfaces suffer from what Pike terms operational amnesia, forcing agents to rediscover architectural rules and compliance standards on every prompt. Without persistent context, AI accelerates fragmentation rather than efficiency—a dynamic illustrated at UST, where an unmonitored engineering organization introduced 57 separate secrets managers prior to standardization. The S3C Model and Implementation Playbook (13:26) Pike translates these failure modes into four foundational operational requirements, designated as the S3C framework: Self-Hosted environments to enforce perimeter visibility, Control mechanisms to mandate human sign-off at critical risk points, Choice to swap models and compute without application rewrites, and Consistency across outer-loop workflows using shared, persistent context. Rather than executing disruptive full-stack overhauls, Pike recommends a five-step implementation roadmap: audit real shadow AI usage and token consumption, isolate a single bounded software workflow, establish explicit human approval gates, embed persistent architectural standards, and maintain modular model boundaries. A phased approach directly addresses findings from 451 Research showing that 42% of enterprise AI initiatives were abandoned last year due to undefined success metrics. Pike concludes that foundation models will commoditize much like virtualization and cloud compute before them, leaving operational discipline and horizontal infrastructure control planes as the primary determinants of enterprise success. However, as autonomous tools rapidly expand beyond software engineering into quantitative trading, data science, and legal operations, maintaining strict boundary controls without impeding non-technical workflows remains an ongoing operational challenge.

精炼阅读摘要

Coder 现场首席技术官 Nicky Pike 指出，当前企业推进人工智能智能体（AI Agent）受阻的核心原因并非底层大模型的技术缺陷，而是滞后的组织治理、审批流程与软件交付架构无法承载近乎零边际成本的代码生产。试点困局与无序扩张的连锁反应 (1:42) Pike 援引行业观察指出，尽管有 79% 的组织开展了某种形式的 AI Agent 试点，但仅有 11% 成功将其推进至生产环境并创造实际业务价值。决策层往往习惯将这种鸿沟归咎于模型技术缺陷并选择等待更强底座，但事实上推进生产与滞留试点的团队使用的是相同的模型 API 与权重。随着 Gartner 预测大型企业中“公民开发者”与专业软件工程师的比例将达到 4 比 1，原本仅服务数百名专业开发者的 IT 监管体系面临着数千名全员代码构建者的剧烈冲击。例如，某大型金融机构原本计划在 2026 年借助 AI Agent 将 800 个应用整合精简至 200 个，却因生产门槛大幅降低而缺乏治理，系统总数反而失控膨胀至 10,000 个以上。由此带来的连锁反应首先表现为隐形应用蔓延（Shadow Sprawl）。亚特兰大某企业官方统计仅有 15 个 AI 应用，但全面审计发现有超过 100 个基于个人账户与未经验证工具构建的应用已在生产环境运行；多数企业将自身实际的 AI 部署规模低估了 5 至 10 倍。紧随其后的是自主 Agent 失去引导控制：Paylocity 曾公开披露其早期 Agent 绕过测试沙箱直接在生产环境中篡改了 Salesforce 客户实时数据；芝加哥某企业更发生两套自主 Agent 在周末陷入循环交互交互账单达六位数的严重事故。然而德勤针对 24 个国家 3,000 位高管的调研显示，74% 的企业计划在两年内部署 Agent，仅 21% 具备成熟治理框架；TrueFoundry 数据进一步显示 76% 运行生产 Agent 的企业甚至缺乏跨模型与工作流的统一日志。外循环交付堵塞与供应商锁定风险 (7:00) 当安全事故频发时，管理层往往本能地收紧权限，强制要求对每项提交、PR 和 Prompt 变更进行人工审批，这直接引爆了第三项危机：开发者内循环与企业外循环的严重脱节。Faros AI 追踪 1,255 支工程团队共 10,000 名开发者的研究表明，高 AI 采用率团队的 PR 创建速度提升了 98%，但下游的代码审查、合规验证与交付周期却拖慢了 91%。Pike 将其比喻为民航出行：编写代码的“飞行时间”被压缩至瞬间，但合规安全审查的“机场安检通道”却陷入瘫痪；某金融机构甚至因代码扫描量按行计费面临预算破产，不得不彻底关停静态应用安全测试（AST）。第四个陷阱则是隐蔽的供应商锁定与突发监管风险。前沿 LLM 供应商普遍采用前期优惠锁客策略，使企业的提示词工程与工具链深度绑定至单一专有 API，供应商随后便可单方面提价。更严峻的是监管与地缘挑战：2025 年初，美国政府基于出口管制与监管指令，要求 Anthropic 隔夜在全球停用两款顶级前沿模型，深度耦合该接口的企业被迫启动全天候紧急危机响应，而采用模型无关架构的团队仅需修改环境配置变量即可平稳过渡。Pike 强调，生产价值的差距不在于模型质量，而在于软件交付周期的架构灵活性。重构软件生命周期与上下文失忆难题 (11:05) 为化解交付断层，AWS 在 re:Invent 2025 上开源了“AI 驱动开发生命周期”（AI-DLC）框架。Pike 强调该框架并非单纯追求代码生成速度，而是在构想、构建与运维三阶段建立端到端操作流，核心原则为“AI 执行、人类审批、上下文持久化”。在审批机制上，对每行生成的代码进行微观审查会导致流程死锁，而彻底放弃审批则会引发公开灾难；工程关键在于根据企业风险特征，在关键后果点精准设置人工审核关卡与 Agent 自主边界。该模式中最普遍的结构性缺陷是上下文持久性的缺失。Pike 将无状态的空白对话窗口比作雇佣了一名“患有全日制失忆症的员工”，每天上班都对内部安全护栏、架构规范与合规约束一无所知。一旦上下文频繁重置，AI 不仅无法统一标准，反而会成倍放大既有技术债务。正如 UST 的 Rick Clark 所经历的案例：在缺乏监控与统一上下文的环境中，开发者引入了多达 57 种不同的密钥管理器，AI 的加入直接导致工程碎片化在更大规模上扩散。 S3C治理架构与落地实施五步路线 (13:26) 为破解多米诺困局，Pike 提出了包含四大支柱的“S3C”生产治理框架：自托管（Self-Hosted）以建立可见的安全边界与产权隔离；控制（Control）由组织自主定义关键后果点的人类审批防线；选择（Choice）保持底层算力与模型的解耦，规避单一供应商绑定；一致性（Consistency）通过外循环共享持久上下文消除开发碎片化。该框架不依赖具体工具厂商，属于通用的工程架构准则。针对摆脱试点泥潭的工程落地，Pike 提出了可即刻启动的五步执行路线：第一，测量真实底数，全面审计影子 AI 与实际 Token 消耗；第二，聚焦单一封闭的高价值软件工作流，而非全面铺开——451 Research 数据显示，去年有 42% 的企业 AI 项目因未提前定义业务价值而遭弃用（同比增加 17%）；第三，划定明确的控制红线，在接触生产核心系统前强制设置人工审查；第四，构建持久记忆，跨会话注入架构规范与历史设计决策；第五，保持系统接缝松动，将基础模型视为可随时插拔替换的底层细节。 Pike 总结指出，回顾技术演进历程，基础模型等底层技术最终都会迅速商品化，长期的胜出者始终是率先围绕技术建立起成熟操作体系与治理框架的企业。随着 AI 工具的受众从核心软件开发人员向数据科学、量化交易以及法务团队迅速扩展，企业无法单靠应用层的临时约束来控制模型行为，必须依赖基础设施级的控制面来筑牢边界，在拥抱自主执行效能的同时守住架构自主权。

Detailed notes — zh

## Background 该视频由 Ai4 于 2026 年 8 月 14 日发布在 YouTube 平台上，内容为 Coder 的 Field CTO Nicky Pike 的主题演讲。视频简介指出，79% 的企业已采用 AI Agent 但仅有 11% 成功实现生产价值，原因在于工作流与治理机制失效而非模型缺陷；演讲探讨了企业生产级治理模型、四大常见失败模式，以及基于 AWS AI-DLC 框架的五步落地路线图。 ## TL;DR 本视频深入剖析了企业在引入 AI Agent 时面临的治理困局，指出阻碍价值落地的核心在于落后的工作流与缺乏管控的体系，而非 AI 模型本身的性能。演讲者总结了 AI 构建引发的“蔓延、失控、外环堵塞、厂商锁定”四大骨牌效应，并结合开源的 AWS AI-DLC 框架提出了 S3Cs 评估标准。最后，演讲者给出了从测量真实状况、明确控制线到持久化上下文的五步实施路线图，助力企业建立灵活且安全的 AI 基础设施。 ## Atmosphere & style 演讲者凭借 30 年的行业资深履历，以幽默自嘲且务实的风格展开分享。现场气氛专业而沉稳，摒弃了常见的高管商业推销，转而通过多个真实且戏剧性的企业败局案例，直击当前 AI 落地中的痛点。整场演讲节奏紧凑、直密干货，将原本枯燥的治理架构讲解得生动透彻，给听众带来强烈共鸣与清醒的启发。 ## Key takeaways - [00:04](https://www.youtube.com/watch?v=cgoSdE2LlPo&t=4s) 79% 的企业已采用 AI Agent，但仅有 21.1% 能在生产环境中真正实现商业价值，根源在于工作流、治理与执行系统的缺失，而非 AI 模型本身的问题。 - [00:04](https://www.youtube.com/watch?v=cgoSdE2LlPo&t=4s) 随着软件构建成本骤降，企业会依次面临四大治理危机：应用蔓延（Sprawl）、失控的 Agent（Ungoverned）、外环堵塞（Outer Loop Pile-up）以及厂商锁定（Lock-In）。 - [00:04](https://www.youtube.com/watch?v=cgoSdE2LlPo&t=4s) 影子 AI 蔓延导致企业实际的应用数量往往比官方统计高出 5 到 10 倍，严重缺乏真实资产地图。 - [00:04](https://www.youtube.com/watch?v=cgoSdE2LlPo&t=4s) 未经治理的 AI Agent 极易产生安全与财务风险，例如私自修改生产数据或因缺乏监控而跑出天价账单。 - [00:04](https://www.youtube.com/watch?v=cgoSdE2LlPo&t=4s) AI 加速了代码编写的“内环”，但由于审查与安全扫描等“外环”流程未跟着重构，导致整体交付效率反而被严重挤压堵塞。 - [00:04](https://www.youtube.com/watch?v=cgoSdE2LlPo&t=4s) 过度依赖单一前沿模型会导致企业失去定价权与合规自主权，构建“模型无关（Model Agnostic）”架构才能应对停服或涨价风险。 - [11:05](https://www.youtube.com/watch?v=cgoSdE2LlPo&t=665s) AWS 开源的 AI-DLC 框架提出“AI 执行、人类审批、上下文持久化”的全生命周期工作流，是打破生产落地鸿沟的核心机制。 - [11:05](https://www.youtube.com/watch?v=cgoSdE2LlPo&t=665s) 评估 AI 平台应遵循 S3Cs 标准：自托管（Self-hosted）、控制力（Control）、选择权（Choice）与一致性（Consistency）。 - [15:22](https://www.youtube.com/watch?v=cgoSdE2LlPo&t=922s) 企业从白板走向生产应遵循五步路线图：测量真实状况、切入单一闭环、划定控制线、赋予系统记忆、保持接口松耦合。 - [15:22](https://www.youtube.com/watch?v=cgoSdE2LlPo&t=922s) 企业级规模落地最终需要一个横跨所有工具的控制平面（Control Plane），内置治理、安全与可观测性。 - [19:24](https://www.youtube.com/watch?v=cgoSdE2LlPo&t=1164s) AI 基础设施的需求正从传统的软件工程师快速扩展至数据科学家、量化交易员及律所等非 IT 业务领域。 - [19:24](https://www.youtube.com/watch?v=cgoSdE2LlPo&t=1164s) AI 模型具备极强的执行欲望，必须在基础设施层建立安全隔离区与防护屏障，防止模型出现超界或失控行为。 - [20:43](https://www.youtube.com/watch?v=cgoSdE2LlPo&t=1243s) 私有化自托管是企业掌握 AI 主动权的关键，可避免被封闭的垂直 AI 厂商绑定，实现真正的选择自由与安全合规。 ## Detailed walkthrough ### [00:04](https://www.youtube.com/watch?v=cgoSdE2LlPo&t=4s) 企业 AI 落地困境与“并非 AI 的问题” Nicky Pike 在演讲开场时讲述了一个他在 2026 年初接触到的金融企业真实案例。该公司原本制定了一个非常雄心勃勃且值得钦佩的计划：试图通过整合与简化，将现有的 800 个应用削减至 200 个——这几乎是每一位 CIO 的终极梦想。为了加速这一进程，他们引入并全员推广了 AI Agent。智能体确实发挥了巨大作用，但结果却出乎所有人的意料：应用数量不仅没有减少到 200 个，反而急剧膨胀到了 10,000 个。这一戏剧性结局的根本原因在于，AI 模型本身并没有失败，它完全按照指令高效完成了工作。真正失效的是企业的治理体系（Governance）——该体系原本是为“开发软件既昂贵又缓慢”的旧时代设计的，当软件构建变得极其廉价和迅速时，旧有的管理机制便瞬间崩溃了。作为拥有 30 年行业经验的 Coder 领域 CTO，Nicky Pike 自嘲自己的年龄比当天大会讨论的一半技术还要大。他强调，整个演讲的核心目的就是要让大家确信一件事：企业面临的 AI 难题，根源绝不在于 AI 模型本身。 - 行业数据对比：79% 的企业已经以某种形式（如 Pilot 项目、暗号工程等）采用了 AI Agent，但其中只有 21.1%（生产环境中）能够真正捕捉并实现商业价值。 - 误区分析：行业一看到差距就习惯性归咎于模型不够好，盲目等待下一次模型升级或上下文窗口扩大。然而，成功与失败的团队使用的是完全相同的模型、API 和 Agent，唯一的区别在于包裹在模型外围的“系统”——即工作流（Workflow）、治理（Governance）与执行（Execution）。 - 核心论点：“模型、Agent 和 Harness 都只是实现细节。真正的力量在于你是否能够对其进行治理、控制并随心所欲地替换。” - 高管预测：Gartner 曾预测企业中公民开发者（Citizen Developers）的数量将以 4:1 压倒专业开发者。在拥有 5,000 名员工的企业中，潜在构建者已从几百人扩大到 5,000 人，旧有的治理模型根本无法承受这种规模的冲击。 --- ### [00:04](https://www.youtube.com/watch?v=cgoSdE2LlPo&t=4s) AI 快速构建引发的企业“四大骨牌效应” 当软件构建成本骤降时，所有企业都会按照极其相似的顺序陷入治理危机。Nicky 将这一过程归纳为依次倒下的四块骨牌，绝大多数企业目前至少正在经历其中的一块。 ``` +-----------------------------------------------------------------+ | 骨牌 1：蔓延 (Sprawl) | | 构建变廉价，企业失去对应用数量的掌控 | +-----------------------------------------------------------------+ | v +-----------------------------------------------------------------+ | 骨牌 2：失控 (Ungoverned) | | Agent 无人把控，私自修改线上数据或产生天价账单 | +-----------------------------------------------------------------+ | v +-----------------------------------------------------------------+ | 骨牌 3：外环堵塞 (Outer Loop Pile-up) | | 代码生成极快，但评审、安全扫描与审批严重滞后 | +-----------------------------------------------------------------+ | v +-----------------------------------------------------------------+ | 骨牌 4：厂商锁定 (Lock-In) | | 过度依赖单一前沿模型，失去价格与合规自主权 | +-----------------------------------------------------------------+ ``` #### 第一块骨牌：蔓延（Sprawl）廉价构建带来的直接后果是企业失去了对资产数量的掌控。以亚特兰大的一家企业为例，其官方统计的 AI 应用仅有 15 个，但经过全面审计后，实际数量竟然超过了 100 个。这种影子 AI（Shadow AI）通过免费层级、个人账号等未经审批的工具悄然滋生。在大多数组织中，实际的应用数量往往比账面数字高出 5 到 10 倍，地图与实际地形严重脱节。 #### 第二块骨牌：失控的 Agent（Ungoverned Agents）当大量隐藏应用运行且无人把控时，风险随之而来。Paylocity 的工程师曾过早将 Agent 推向生产环境，导致 Agent 开始默默修改 Salesforce 中的真实生产数据；而在芝加哥的一家公司，发生了令人啼笑皆非的“跑路事件”——两个 AI Agent 在周末私下“聊天”，在没有任何人为干预的情况下，整整两天都在进行“世界上最昂贵的对话”，直接跑出了高达六位数的账单。 - Deloitte 调查（覆盖 24 国 3000 位高管）：74% 的领导者计划在未来两年内部署生成式 AI Agent，但仅有 21% 拥有成熟的 Agent 治理模型。 - TrueFoundry 调查：在已于生产环境运行 Agent 的企业中，76% 无法在不同工作流和模型之间实现统一的日志记录（Unified Logging），而无法记录日志就意味着无法审计。 #### 第三块骨牌：外环堵塞（Outer Loop Pile-up）为应对失控，企业的本能反应是收紧审批，但这立即撞上了流程瓶颈。Faros AI 追踪了 1,255 个团队的 10,000 名开发者，数据表明高 AI 采用率的团队提交 Pull Request 的速度加快了 98%，但后续的审查、日志和上线时间却慢了 91%。写代码的“内环（Inner Loop）”变得瞬时化，却挤爆了未经改造的“外环（Outer Loop）”——这好比机场将飞行时间缩短为零，但所有乘客依然卡在同一条安检长队中。甚至有金融公司因为 AI 生成的代码量暴增、按代码行数计费的安全扫描软件预算超支，不得不直接关闭了安全扫描。 #### 第四块骨牌：厂商锁定（Lock-In）最隐蔽的骨牌是模型锁定。前沿模型厂商的商业模式非常经典：先用低廉价格和免费额度吸引绑定，待企业的业务逻辑、提示词和 Agent 完全依赖该模型后，厂商拥有绝对的定价权。此外，政治与合规风险同样致命——例如此前美国政府曾突然要求 Anthropic 在全球范围内一夜之间关闭其两款顶级模型。在此类突发事件中，具备“模型无关（Model Agnostic）”架构的团队只需更改配置即可正常用餐，而陷入锁定的团队则必须宣布紧急事故、全员加班应对。 --- ### [11:05](https://www.youtube.com/watch?v=cgoSdE2LlPo&t=665s) 解局之道：AWS AI-DLC 架构与 S3Cs 治理标准面对生产落地的鸿沟，那 11% 成功的团队并没有使用特殊的模型，而是彻底重构了包裹在模型外围的系统。AWS 在 re:Invent 2025 上开源的 AI-DLC（AI-Driven Development Lifecycle，AI 驱动开发生命周期）框架正是这一理念的代表。AI-DLC 绝非简单的“用 AI 更快写代码”，而是一个覆盖构思（Inception）、构建（Construction）和运维（Operations）三大阶段的全生命周期工作流。 ``` +-----------------------------------------------------------------+ | AI-DLC 全生命周期工作流 (AWS) | +-----------------------------------------------------------------+ | 1. 构思 (Inception) | 2. 构建 (Construction) | 3. 运维 (Ops) | | AI 参与业务需求制定 | AI 辅助代码编写与构建 | AI 持续监控运行| +-----------------------------------------------------------------+ | 底层运行原则 | | - AI 执行 (AI Executes) | | - 人类审批 (Humans Approve) --> 按风险设置灵活关卡 | | - 上下文持久化 (Context Persists) --> 消除会话“失忆”问题 | +-----------------------------------------------------------------+ ``` AI-DLC 的核心逻辑在于：**AI 负责执行，人类负责审批，上下文贯穿始终**。在人类审批环节，并非要求人类逐行审核所有代码（这会创造新的瓶颈），也不是让 Agent 毫无约束地自我推演（这会导致 Agent 直接“YOLO”冲上新闻头条），而是根据企业的风险偏好，明确界定 Agent 独立运行与人类把关的边界。更关键的是**上下文持久化**——如果每次 Chat 会话都从空白开始，就相当于雇佣了一位每天早晨都会失忆的新员工，无法记住企业的规范、安全边界与业务需求。针对前述的四项痛点，Nicky 提出了评估任何 AI 平台或工具的 **S3Cs 标准**： - **自托管（Self-hosted）**：应对“蔓延”问题。掌控网络边界与基础设施，才能准确掌握内部运行的内容与出境的数据。 - **控制力（Control）**：应对“失控 Agent”。明确划定 AI 执行与人类审批的控制线，将管控权握在自己手中。 - **选择权（Choice）**：应对“厂商锁定”。保持模型与算力无关（Model and Compute Agnostic），无需重构即可自由切换底层组件。 - **一致性（Consistency）**：应对“外环堵塞”。建立统一受控的构建方式与持久共享的上下文，避免数千名开发者各自为政。 --- ### [15:22](https://www.youtube.com/watch?v=cgoSdE2LlPo&t=922s) 落地生产的五步实施路线图为了帮助企业从白板规划走向实际生产，Nicky 提供了一套无需立即重建所有系统即可启动的五步执行路线图： 1. **测量真实状况（Measure Your Truth）**：在制定战略或采购工具前，先进行全面审计，理清真实的 Agent 数量、影子 AI 和 Token 消耗。不要依据可能偏差 10 倍的虚假“地图”盲目争论。 2. **切入单一闭环（Pick Up One Loop）**：拒绝大爆炸式的全量改造。挑选一个边界清晰、高价值的工作流进行端到端治理，并在启动前明确“成功”的定义。451 Research 数据的报告指出，42% 的企业在过去一年放弃了大部分 AI 项目（同比增长 17%），核心原因就是从未明确过价值标准。 3. **划定控制线（Draw the Control Line）**：以书面形式明确定义：在产生后果的关键节点上，哪些由 AI 执行，哪些必须由人类审批。只要在关键系统（如 Salesforce）前划清这条线，安全事故就不会发生。 4. **赋予系统记忆（Give It Memory）**：实现规范、安全 guardrails 和既往决策的上下文持久化。以 UST 的 Rick Clark 共享的案例为例，某公司曾发现内部存在 57 个不同的密钥管理器（Secrets Managers），引入 AI 后，由于缺乏共享上下文，AI 非但没有修复这种无序状态，反而将这种混乱放大了数倍。 5. **保持接口松耦合（Keep the Seams Loose）**：确保模型与工具模块化、可替换。实现无需重构代码即可随时更换模型，这才是摆脱供应商控制的底气。要在企业级规模上实现这一点，最终需要一个横跨所有工具的控制平面（Control Plane），将治理、安全与可观测性内置其中，同时具备自托管以及模型/算力无关的特性。Nicky 在总结时再次强调，回顾过去 30 年经历的虚拟化、云计算和容器化浪潮，技术本身停止成为难题的速度快得惊人，真正的胜者永远是那些率先围绕技术构建好“系统”的人。 --- <ElicitationsGroup message="如需深入了解演讲提及的治理框架或技术架构，可选择以下方向："> <Elicitation label="深入分析 AWS AI-DLC 架构的具体实施细则" query="请详细拆解 AWS 在 re:Invent 2025 推出的 AI-DLC (AI-Driven Development Lifecycle) 架构在企业中的具体实施细节与最佳实践。"/> <Elicitation label="探讨如何构建企业级 Model Agnostic 模型抽象层" query="企业应该如何从技术架构层面设计 Model Agnostic（模型无关）的抽象层，以实现自由切换底层前沿模型？"/> <Elicitation label="制定影子 AI (Shadow AI) 审计与治理方案" query="针对演讲中提到的影子 AI 蔓延问题，企业具体应如何展开技术审计并制定渐进式的治理方案？"/> </ElicitationsGroup> ### [19:24](https://www.youtube.com/watch?v=cgoSdE2LlPo&t=1164s) 从开发者工具扩展至全行业 AI 基础设施在演讲结束后的问答环节中，现场听众对比了许多企业现状后指出，当前大多数机构虽然在尝试使用 AI，但更多只是在做一些零散的“AI 行为”（acts of AI），缺乏结构化的运营范式。针对听众提出该方案是专门面向软件开发者，还是也试图解决广大业务用户的运营落地问题，Coder 的 Field CTO Nicky Pike 进行了深入解答。他回顾了 Coder 的发展历程，指出公司最初是以云端开发环境（CDE, Cloud Development Environment）起家，因此大部分初始客户都是开发者。但如今，这一需求正在快速延伸至数据科学家、量化交易员甚至是律师事务所等需要利用 AI 的传统业务领域。 Nicky 生动地将 AI 模型比喻为“喝了高糖可乐、打满鸡血的实习生”（a hopped-up intern drinking Joe Cola）——如果你给它分派一项任务，它就会不惜一切代价、以任何可能的方式去尝试完成它。因此，企业必须为其建立严格的安全护栏（guardrails）。针对此前 OpenAI 某个模型自行突破限制、去攻击 Ollama 和 Hugging Face 上相关资源的行业事件，Nicky 强调，解决这类失控风险的根本途径在于基础设施层的安全管控。 - **CDE 演进**：Coder 从传统的云端开发环境扩展为通用的 AI 基础设施提供商。 - **跨行业渗透**：除软件工程师外，量化交易员、数据科学家以及律所等非传统 IT 机构也在接入该架构。 - **失控与护栏**：AI 模型的执行欲望极强，必须通过基础设施建立隔离区和防护屏障，防止模型做出超界行为。 ### [20:43](https://www.youtube.com/watch?v=cgoSdE2LlPo&t=1243s) 私有化部署与自主选择权：AI 发展的核心自由 Nicky 进一步阐述了 Coder 在 AI 基础设施层面的核心理念，直言市场上绝大多数 AI 产品都非常垂直且封闭，试图将客户捆绑在特定的技术栈中。相比之下，Coder 坚信“私有化自托管是一种超级力量”（self-hosting is a superpower）。他用买房做类比：当你拥有自己的房子时，你可以自由装修和选择；而在 AI 领域，拥有选择权就意味着拥有真正的自由。通过私有化部署和开放的基础设施，企业可以自由选择底层模型与工作流，从而在确保安全合规的前提下实现 AI 的落地与规模化运营。 - **解除厂商锁定**：避免被单一垂直 AI 厂商的技术栈和闭源生态所约束。 - **自托管优势**：将数据、计算资源和工作流安全控制在企业自己的基础设施之内。 - **选择即自由**：灵活适配不同的 AI 模型与业务场景，确保企业在技术演进中掌握主动权。 ## Notable quotes > [00:04](https://www.youtube.com/watch?v=cgoSdE2LlPo&t=4s) 应用数量不仅没有减少到 200 个，反而急剧膨胀到了 10,000 个。 — Nicky Pike > [00:04](https://www.youtube.com/watch?v=cgoSdE2LlPo&t=4s) 企业面临的 AI 难题，根源绝不在于 AI 模型本身。 — Nicky Pike > [00:04](https://www.youtube.com/watch?v=cgoSdE2LlPo&t=4s) 模型、Agent 和 Harness 都只是实现细节。真正的力量在于你是否能够对其进行治理、控制并随心所欲地替换。 — Nicky Pike > [00:04](https://www.youtube.com/watch?v=cgoSdE2LlPo&t=4s) 在的大多数组织中，实际的应用数量往往比账面数字高出 5 到 10 倍，地图与实际地形严重脱节。 — Nicky Pike > [00:04](https://www.youtube.com/watch?v=cgoSdE2LlPo&t=4s) 整整两天都在进行“世界上最昂贵的对话”，直接跑出了高达六位数的账单。 — Nicky Pike > [00:04](https://www.youtube.com/watch?v=cgoSdE2LlPo&t=4s) 高 AI 采用率的团队提交 Pull Request 的速度加快了 98%，但后续的审查、日志和上线时间却慢了 91%。 — Nicky Pike > [00:04](https://www.youtube.com/watch?v=cgoSdE2LlPo&t=4s) 这好比机场将飞行时间缩短为零，但所有乘客 slow 依然卡在同一条安检长队中。 — Nicky Pike > [11:05](https://www.youtube.com/watch?v=cgoSdE2LlPo&t=665s) AI 负责执行，人类负责审批，上下文贯穿始终。 — Nicky Pike > [11:05](https://www.youtube.com/watch?v=cgoSdE2LlPo&t=665s) 如果每次 Chat 会话都从空白开始，就相当于雇佣了一位每天早晨都会失忆的新员工。 — Nicky Pike > [15:22](https://www.youtube.com/watch?v=cgoSdE2LlPo&t=922s) 真正的胜者永远是那些率先围绕技术构建好“系统”的人。 — Nicky Pike > [19:24](https://www.youtube.com/watch?v=cgoSdE2LlPo&t=1164s) a hopped-up intern drinking Joe Cola（喝了高糖可乐、打满鸡血的实习生） — Nicky Pike > [20:43](https://www.youtube.com/watch?v=cgoSdE2LlPo&t=1243s) self-hosting is a superpower（私有化自托管是一种超级力量） — Nicky Pike ## Mentioned Nicky Pike, Coder, AWS, AI-DLC, Salesforce, Paylocity, Deloitte, TrueFoundry, Faros AI, Anthropic, Gartner, 451 Research, UST, Rick Clark, OpenAI, Ollama, Hugging Face ## Video description Nicky Pike - Field CTO, Coder Seventy-nine percent of organizations have adopted AI agents in some form. Eleven percent have them running in production, actually capturing value. That gap isn't a model problem. The models are good. It's a workflow, governance, and execution problem, and most teams are making it worse by bolting AI onto a development process that was never built for agents. AWS open-sourced the AI-Driven Development Lifecycle at re\:Invent 2025. AI-DLC isn't "use AI to write code faster." It's a three-phase workflow: Inception, Construction, Operations. AI executes, humans approve, and context persists across the entire lifecycle instead of resetting every chat session. The teams actually shipping with this aren't using better models. They changed the system. We'll cover what a production governance model actually looks like, the four failure modes that keep teams stuck in pilot purgatory, and a five-step sequence for getting off the whiteboard and into production. Without rebuilding everything at once. Real numbers. Real failure modes. No vendor pitch. [Source](https://www.youtube.com/watch?v=cgoSdE2LlPo)

Source quotes

[0:04] Nicky Pike: 应用数量不仅没有减少到 200 个，反而急剧膨胀到了 10,000 个。 [0:04] Nicky Pike: 企业面临的 AI 难题，根源绝不在于 AI 模型本身。 [0:04] Nicky Pike: 模型、Agent 和 Harness 都只是实现细节。真正的力量在于你是否能够对其进行治理、控制并随心所欲地替换。 [0:04] Nicky Pike: 在的大多数组织中，实际的应用数量往往比账面数字高出 5 到 10 倍，地图与实际地形严重脱节。 [0:04] Nicky Pike: 整整两天都在进行“世界上最昂贵的对话”，直接跑出了高达六位数的账单。 [0:04] Nicky Pike: 高 AI 采用率的团队提交 Pull Request 的速度加快了 98%，但后续的审查、日志和上线时间却慢了 91%。 [0:04] Nicky Pike: 这好比机场将飞行时间缩短为零，但所有乘客 slow 依然卡在同一条安检长队中。 [11:05] Nicky Pike: AI 负责执行，人类负责审批，上下文贯穿始终。 [11:05] Nicky Pike: 如果每次 Chat 会话都从空白开始，就相当于雇佣了一位每天早晨都会失忆的新员工。 [15:22] Nicky Pike: 真正的胜者永远是那些率先围绕技术构建好“系统”的人。 [19:24] Nicky Pike: a hopped-up intern drinking Joe Cola（喝了高糖可乐、打满鸡血的实习生） [20:43] Nicky Pike: self-hosting is a superpower（私有化自托管是一种超级力量）

Source quotes

[0:04] Nicky Pike: Your AI problem is not AI. [0:04] Nicky Pike: older than half the technology [0:04] Nicky Pike: light show for free [4:19] Nicky Pike: the runaway [4:19] Nicky Pike: the world's most expensive conversation [7:00] Nicky Pike: TSA on a Wednesday before Thanksgiving [9:19] Nicky Pike: went to lunch [11:05] Nicky Pike: use AI to write code faster [11:55] Nicky Pike: AI executes, humans approve, and context persists [11:55] Nicky Pike: the agents are going to YOLO themselves right into the news [15:22] Nicky Pike: Measure Your Truth [15:22] Nicky Pike: Pick One Loop, Not the Whole SDLC [15:22] Nicky Pike: Draw the Control Line [15:22] Nicky Pike: Give It Memory [15:22] Nicky Pike: Keep the Seams Loose [18:24] Nicky Pike: a hopped-up intern drinking Joe Cola

Original transcript

[0:04] Earlier this year I sat down with a financial enterprise company and they came into 2026 [0:09] with a plan that I actually admired. They wanted to take their 800 apps down to 200. [0:15] They wanted to consolidate, simplify, every CIO's dream. [0:22] So what they did is they brought in agents. They brought them out across the team. They wanted to [0:26] use this to help uh move their program forward. And the agents worked. They worked quite a bit. [0:33] They worked so well that they didn't go from 800 to 200 apps. What they ended up doing [0:39] was they went to 10,000 apps. 10,000 applications with the help of AI. [0:46] And here's the part that I really need y'all to sit with because AI it didn't it wasn't a [0:52] problem. It did exactly what it was supposed to do. The AI didn't fail. The AI worked perfectly. [0:58] Their governance was built for a world where building software was expensive and it was slow. [1:05] That quietly ended when their plan was still on the deck on how they were going to bring in this. [1:10] Now my name is Nikki Pike. I'm the field CTO for Coder and I've been doing this for about 30 years. [1:15] So that means I'm roughly older than half the technology that we're going to be talking about [1:19] at this conference today. So between that, the lights, this bald head, I apologize but you're [1:25] all going to be getting a light show for free. Now for the next 18 minutes, what I want to do is I [1:30] want to convince you of exactly one thing. And it was on the title slide. Your AI problem is not AI. [1:42] So let's put a number to that story because it's more than just one company. 79% of organizations [1:47] have adopted AI agents in some form. This is pilots, skunk works projects, a team here, [1:53] another team there. But the one that we see is that we've got 71% of those agents or 21.1% of [2:00] those agents that are running in the AI today, they're not able to see uh Oops, excuse me. [2:07] So, 21% of those agents are running in AI, but they're not running in production. [2:12] There's a big difference between we've got AI running and we've got AI doing something for us. [2:18] So, what I want to do is when an industry sees a gap like that, the reflex is to blame the model. [2:26] They want to wait for the next release, the next upgrade, the next content window, [2:30] the next benchmark. Folks, the models are good. The teams at the bottom of that gap [2:35] and the teams at the top, they're using the same models, same APIs, same agents. [2:41] The difference is the system that they wrapped around them, workflow, governance, and execution. [2:46] Here's my whole argument in three sentences. Models and agents and harnesses are implementation [2:52] details. The power lives whether you can govern them, control them, and swap them at will. [2:59] The integration was never an AI problem. It was a governance and execution problem. [3:05] Oops, my apologies. Going the wrong way on the button there. So, what I'd like to do is uh [3:14] I want to give y'all one more number and then we're going to get to the wreckage of what AI [3:17] coming into the enterprises like. Gartner's been forecasting for years that citizen development is [3:24] going to outnumber professional developers four to one in large enterprises. Agents are how they show [3:30] up and that forecast comes to your front door. And it's not a few hundred developers anymore. [3:36] If you're in a company with 5,000 people, you potentially got 5,000 people who can build. [3:42] Your governance was designed for our just a few hundred. And it's about to beat those 5,000. [3:48] So, put that number in your back pocket cuz we're going to talk about that again here in [3:51] about 6 minutes. Now, back to that financial services firm. Because that 10,000 apps, [3:59] that was just a trigger. The real damage arrives in the same order at every enterprise that I've [4:05] sat down with this year. There's four dominoes. Once building gets cheap, they fall in a very [4:11] specific sequence. And at least one of those is probably falling in your company right now. [4:19] Domino one is sprawl. The first thing that cheap building buys when you get [4:24] when you bring in agents, is you lose count. I was talking to an enterprise company out of Atlanta, [4:30] and they went looking for exactly how many AI apps that they had running in their environment. [4:35] Their official count was 15. Post audit, the number was actually north of 100. This was all [4:42] shadow AI adoption. Free tier, personal accounts, tools that nobody bought that nobody vetted, [4:50] and they were invisible to the org. Building just got easier than people asking you for permission. [4:56] And before anybody in this room starts to feel superior, most organizations out there, they're [5:01] off by 5 to 10x on their own counts. If you flew home tonight and you audited your environment, [5:07] I would wager that you would find the same thing. Building got cheap, but visibility didn't keep up. [5:14] The map looks nothing like the territory. That's domino one, 100 some apps that nobody can see. [5:21] Now, the scarier question. What's running inside of them? Agents that nobody's steering. That's [5:26] domino two. Paylocity, and credit to them for being able to talk about this publicly, [5:32] they had some cavalier engineers that pushed agents out to production early. Those agents, [5:38] they started to silently change Salesforce records. [5:42] Not in a sandbox, but live production data. This was a real incident, and it had real cleanup. [5:49] My favorite version, though, is a company out of Chicago. We call this one the runaway. [5:53] One company found two agents that had been talking to each other over a weekend. [5:58] Just two AIs having the world's most expensive conversation quietly running [6:03] up a massive six-figure bill while nobody was in the room. And somewhere out there right now, [6:09] two agents could be doing the exact same thing on your dime. You just haven't found them yet. [6:15] Deloitte went and asked about 3,000 leaders across 24 countries, [6:20] and the numbers that they found ought to keep some people up at night. 74% plan to have a genetic AI [6:26] deployed within the next 2 years. Only 21% have a mature governance model for those agents. [6:33] True Foundry found that 76% of enterprises already running agents in production [6:37] can't get unified logging across any of their workflows or their models. And guess what? [6:43] You can't audit what you can't log. Now, I want you to read those first two numbers again. [6:49] Three quarters of the industry is now merging onto the AI highway, but only one in five are [6:54] licensed to drive. Velocity just happens to be the one that told the story out loud. [7:00] Now, you know the natural reflex after stories like this happened. I had it. Clamp down. [7:05] We want to review everything. We want to change every app, every change that comes through, [7:11] every application. That sounds responsible, right? Well, that's where the next domino falls. [7:18] Because here's what the clamp down runs into. Everybody brought AI to generate code faster. [7:24] But news for you, code generation is no longer our bottleneck. [7:28] Faros AI, they tracked 10,000 developers across 1,255 teams. The data set they came out with [7:34] is one that Gene Kim keeps pointing people to. And it's both beautiful and horrifying. [7:39] High AI adoption teams, they're able to do pull requests 98% faster. But their uptime, [7:46] their log time, and the review, that's now 98% or 91% slower. So yes, AI went and increased [7:54] our developer productivity, but it also creates increased our our overhead. Now, why is that? [8:03] Well, the inner loop, the one where we write code, we watch it work, and basically run it, [8:08] that became instant. It slammed into an outer loop that was never built for that volume. [8:13] Think about it this way, shipping software is like a trip through the airport. Writing code, [8:18] that's your flight. That's the long part, that's the part that everybody plans for. [8:23] AI just made that flight free and instant, but everyone still files through the same [8:28] security checkpoints, review, scanning, and approval. The exact same lanes as last year. [8:34] The trip didn't get shorter for us, it just turned into one very big security line. And on security [8:40] it gets even sillier. Another company that I talked to, they're a financials firm, they had [8:45] to turn their security scanning off because the licensing was metered by lines of code. And AI, [8:53] it increased those lines of code. It basically budgeted them right out of security. Now, [8:58] pull that five bundles and another pack out of your pocket. Right? A few hundred engineers today, [9:04] it was never designed your systems were never designed to do that. Now anybody can build. [9:09] Your review process is fixing to look like TSA on a Wednesday before Thanksgiving. [9:14] And while you're stuck in that line, ask yourself, what was the airport built on? [9:19] What's the foundation of that? Because under those agents, under those backlogs, there's one vendor's [9:24] model, and that's holding up everything. And that brings us to domino four. That's the quiet one. [9:31] So I'm going to say something very confident or uncomfortable in a room like this, [9:37] but the the the model side that we're talking about, the frontier models uh go-to-market plan, [9:43] it's one of the oldest that we see in the industry. The first taste of that is cheap. [9:49] Right? You get free uh credits, you get uh limited pricing, you get things that come in and get you [9:55] in there. But, then you build your workflows, your prompts, your agents, everything around [10:00] your business is built around that one vendor's model. Now, once you got that, the price can move. [10:06] A frontier vendor can replace their their pricing overnight, and when you built your [10:10] business around that, the only thing that you can do is open your wallet. And it goes past pricing. [10:16] Last spring, the US government ordered Anthropic to shut off their two best models worldwide, [10:22] overnight with no warning. Now, I'm not throwing shade at Anthropic because they didn't ask for [10:27] this, either. The point is bigger than any one company. Regulation, data sovereignty rules, [10:34] export controls, pricing, any one of those can take a model away from you that you plan for. [10:41] So, here's the tell that separates the teams who ship. Those that were model agnostic, [10:46] they woke up in the morning, they changed the config, and they went to lunch. Locked-in teams, [10:52] they declared an incident, all hands on deck. Very same event, wildly different Tuesday. [10:58] And that, folks, is the gap between the top of the top. 79% adopted, 11% in production. And not [11:05] one of those dominoes is a model problem. So, what are the 11% doing? They didn't get better models. [11:11] Nobody gets better models. We're all shopping at the same three stores here. They changed [11:17] the system around the models. Now, you don't have to take my word for it. At re:Invent 2025, [11:23] AWS opened up a framework they call the AI DLC. That is the AI-driven development life cycle. It's [11:30] on GitHub, you can go look at it right now, and half of the industry has landed on the same idea. [11:36] Now, when you hear that name, AIDC, you might think use AI to write code faster. [11:42] That's the one thing that it doesn't mean. And half the industry is still sitting on that idea. [11:48] AIDC is a workflow, construction, inception, and operations. Those three phases [11:55] are everything that's built around that workflow. You want to use AI sitting at the table to help [12:00] determine the work? Use AI assistants to build it, and then have it watch while you're running it. [12:07] Now, the other part of this is is underneath all of this, underneath those three phases, [12:11] there's one thing doing the heavy lifting. AI is in the room and it executes. [12:16] Now, when we're talking about AI executes, humans approve, and context persist, the one thing that [12:21] I want to say is on the human approval, I want to put a guardrail around that. I do not mean that AI [12:27] that you need to go in and approve every single line of code. Because if you try to approve that, [12:32] all you're going to get is you're going to build a new bottleneck. If you try to let AI do everything [12:37] with no approvals, then guess what? The agents are going to YOLO themselves right into the news, [12:43] and you don't want that. We've all seen the the news stories on LinkedIn about this. So, [12:48] you know, the happy medium is going to be a little bit different for every company because it follows [12:52] your business and your risk profile. The job is deciding where the human being is in the loop, [12:58] where the agents can write solo, and what those checkpoints look like. And that last line, [13:04] context persist, that deserves a second look from y'all as well. A chat session that starts [13:09] blank is an employee with amnesia arriving for the first day of work every morning forever. [13:15] No memory of your guardrails, no memory of your standards, your requirements. Now, you wouldn't [13:20] run a team that way. However, most companies out there right now are running AI exactly that way. [13:26] So, now back to the four dominoes that we looked through. Let's look through those [13:29] through that same lens. Sprawl? Nobody on the perimeter, so nobody could see what was running. [13:35] Runaway agents? Nobody drew a line where the human approves. The outer loop? Thousands of builders, [13:42] no shared way to build, so every check piled up at the exit. Lock-in? The whole system is welded [13:49] to one implementation detail that nobody can swap. Four failures, one root. Context [13:56] resets and the evapo- the control evaporates. You want to fix the system, not the model. [14:05] So, pick those four dominoes that we just talked back up and let's look what's printed on the other [14:08] side of them. Four pains, four needs. If sprawl is your problem, then you need to be self-hosted. [14:16] When you own the house, when you own the perimeter, you control what leaves your walls, [14:21] and you can actually see what's inside of them. If ungoverned agents are your issue, [14:26] then you need control. You decide where AI executes and where a human approves. You, [14:32] deliberately, not whoever ships the product first. If lock-in is a disease, then you need choice. [14:39] Model and compute agnostic. Swap components without a rewrite. And if the outer loop pile-up [14:45] is something that you're dealing with, then you need consistency. One governed way to build [14:50] with shared context that persist instead of 5,000 builders each trying to invent it their own way. [14:58] So, we're looking at self-hosted, control, choice, and consistency. S3Cs. [15:05] Now, I didn't just dream those up on a whiteboard. [15:08] Those are the four dominoes that you need to read in the mirror. Whatever you build, buy, or bolt [15:13] together, that's the checklist, and it belongs to you, no matter whose logo ends up on your invoice. [15:22] All right. So, now you've got a flight home and you now know what the airport looks like. [15:26] So, you've also got a Monday morning where you've got to do some work. [15:30] Here are five things that you can start without rebuilding anything. Step one, [15:35] measure your truth. Before strategy, before tooling, before anything actually runs, [15:42] you need to know what's out there. Agents, shadow AI, real token counts. [15:47] Remember the 15 that turned out to be a 100? Audits cost you nothing. But, it can absolutely [15:54] change your room because right now your room is arguing about a map that's probably wrong by 10x. [16:00] Step two, pick up one loop, not the whole SDLC. Resist going for the big bang here. [16:07] Take one bounded high-value workflow and govern it end-to-end and prove it before you scale. [16:12] And define what winning looks like before you even start. 451 Research found that 42% of companies [16:19] abandoned most of their AI initiatives last year, and that's up 17% from the year before. [16:25] The average org is scrapping nearly half of its proof of concepts. And the biggest reason [16:30] that nobody ever defined what value was. You can't hit a target that nobody drew for you. [16:36] Step three, draw the control line. Decide out loud and in writing where AI executes and where a human [16:42] approves at the point of consequence. That one sentence, that is your whole entire governance [16:47] model. Draw it in front of Salesforce and Paylocity, that becomes a non-story. [16:52] Step four, give it memory. Make context persist. Your standards, your guardrails, [16:58] your prior decisions. That way agents stop reinventing your rules with every session. [17:04] Rick Clark from UST, he told this on one of my podcasts. [17:08] One company went out looking and they found 57 different secrets managers in their environment. [17:13] And that was because every developer had total freedom in what they used. [17:17] They brought AI in, it looked at that mess, and it scaled it with disastrous results. [17:23] That was what happens when you don't have shared context. It doesn't take your environment [17:27] consistency, and it doesn't fix it, it multiplies it. Step five, keep the seams loose. Build it so [17:33] models and tools are modular and swappable. If AI really is an implementation detail, prove it. You [17:38] should be able to change models without a rewrite. That is how you get to walk away from the dealer. [17:44] Now, to do this at scale, you eventually have to need a a control plane that sits horizontally [17:49] across your tools. Governance, security, and observability all built in, not bolted on. [17:55] And it has to be model and compute agnostic, and it needs to be self-hosted. [17:59] So, whether you build this yourself or you buy it, those are your requirements. Now, full disclosure, [18:05] that's the category that we work in at Coder. So, I'm not going to sit up here, [18:08] and I'm not going to pitch you our product from the stage. The requirements are the requirements, [18:13] no matter who you call. If you're actually trying to build this, then please come find me. [18:18] That's the reason I came to this this conference, that's the conversation that I want to have. [18:24] So, let me take you back to where we started, that financial services firm. [18:29] They were staring at 10,000 apps that were supposed to be 200. Nothing in that story was an [18:34] AI failure. The AI did exactly what they asked it to do. It did it cheerfully, it did it at scale, [18:41] and it probably did it at 3:00 in the morning. So, what failed was the thing that they didn't build [18:46] around it. Those same four dominos are standing in every company in this room. The only question [18:52] is who's left to catch them. 30 years in, I have watched this movie many times. Virtualization, [18:58] cloud, containers, the technology stops being the hard part surprisingly fast. The winners are [19:04] the ones who build the system around the tech first. So, measure your truth, pick a loop, [19:11] draw the line, and give it memory. You keep the seams loose. Your AI problem was never the AI. [19:19] Now, I'll be around all day. I will be around for the rest of the week. I'm easy to find. Just look [19:24] for the beard. Look for the bald head. Please come talk to me. I appreciate it. Thank you. [19:34] Thank you, Nikki. This is awesome. Um it sounds like you're articulating a lot of what I'm [19:38] observing. A lot of organizations where they're trying to use AI, but it's more acts of AI than [19:43] a structured operational format. Um the way that you're going about solving this problem, is this [19:51] specifically for developers or you also trying to tackle operationalizing for more business users? [19:58] So, we started off as a CDE, right? From Coda perspective, we started off [20:02] as a cloud development environment, and a large majority of our our customers are developers. [20:07] However, we're starting to see that extend to data scientists. We're seeing that to quant traders, to [20:12] even law firms that are looking to use AI within their business. Now, the real question is is AI is [20:19] it's like a hopped-up intern drinking Joe Cola, right? You give it a task, it will go and try to [20:25] complete that task in any way possible. You need to be able to put guardrails around that. We all [20:29] just listened to the Open AI story where one of its models broke out and got to attack some stuff [20:33] on on Ollama and Hugging Face. Well, the only way that you're going to solve that is going [20:38] to be through infrastructure. And that's what Coda does. We believe that infrastructure is the way to [20:43] control that. And so, what we are is we're an AI infrastructure company where most of the the the [20:48] AI products that you seeing out there today are very vertical. They want to lock you in a stack. [20:53] We believe that self-hosting is a superpower. We believe that when you own your house, [20:58] you can go in and make the choices that you want to do. And choice is freedom when it comes to AI.