Pulumi CEO Says AI Models Require Infrastructure Written in Real Code
@Scale
Autonomous AI agents cannot navigate cloud consoles or custom DSLs, forcing developers to model infrastructure in standard programming languages like Python and TypeScript to unlock full software automation.
## Background
This talk was delivered by Joe Duffy from Pulumi, published by @Scale on YouTube on June 26, 2026. The description highlights how modern AI agents face an 'infrastructure gap' when relying on manual consoles or custom domain-specific languages. It explains that by representing infrastructure within real, in-distribution programming languages like Python or TypeScript, LLMs can apply standard coding logic to manage and deploy cloud resources.
## TL;DR
While AI coding tools have vastly increased application code velocity, deploying and managing infrastructure remains a significant friction point akin to 'assembling IKEA furniture.' Because frontier models excel at general-purpose programming languages rather than manual console tasks or obscure DSLs, expressing infrastructure as code allows LLMs to leverage their native training distribution. By representing resources as programmatic objects and using deterministic preview mechanisms like diffs, agents can safely type-check, test, and automate infrastructure pipelines. Ultimately, shifting operations from raw text configuration to full-featured code space enables scalable, highly automated, and agent-managed operations.
## Atmosphere & style
The presentation is authoritative, technical, and forward-looking, delivered with the clear pragmatic optimism of an industry veteran. Duffy blends historical perspective with compelling benchmark metrics and practical Python code samples, creating an engaging narrative arc from early manual cloud friction to fully agentic infrastructure. Listening to the talk feels like an insider look at the future of DevOps, grounded in practical software engineering rather than unbacked hype.
## Key takeaways
- [00:04](https://www.youtube.com/watch?v=P4PpoTH9ADc&t=4s) App code velocity is experiencing a 2x-10x surge and heading toward 100x gains through 24/7 autonomous AI agent teams, but infrastructure management is failing to keep pace.
- [01:27](https://www.youtube.com/watch?v=P4PpoTH9ADc&t=87s) Andrej Karpathy's 'IKEA furniture' analogy illustrates how modern deployment remains bottlenecked by manual operational tasks outside the LLM's reasoning scope, such as cloud consoles, API keys, and copy-pasting configuration.
- [03:09](https://www.youtube.com/watch?v=P4PpoTH9ADc&t=189s) Infrastructure management evolved from manual point-and-click operations to text/YAML configurations, and now to real programming languages (Code Space) like Python, TypeScript, and Go.
- [03:09](https://www.youtube.com/watch?v=P4PpoTH9ADc&t=189s) Expressing infrastructure in real programming languages provides a huge advantage for AI enablement because ergonomic programming abstractions for humans are equally ergonomic for AI agents.
- [04:43](https://www.youtube.com/watch?v=P4PpoTH9ADc&t=283s) Software engineering tasks excel in LLM scaling because code is heavily in-distribution across training data, supported by extensive human documentation and deterministic execution reward signals.
- [04:43](https://www.youtube.com/watch?v=P4PpoTH9ADc&t=283s) Benchmark progress on SWE-bench demonstrates a dramatic reduction in software engineering error rates, jumping from 33% in ~2024 to 86% in 2026, with frontier models targeting 95%+.
- [07:07](https://www.youtube.com/watch?v=P4PpoTH9ADc&t=427s) The Agentic Infrastructure Gap occurs because cloud console navigation and ad-hoc operational runbooks are out-of-distribution for LLMs, leading to hallucinations when autonomous systems lack proper code representations.
- [10:58](https://www.youtube.com/watch?v=P4PpoTH9ADc&t=658s) Framing infrastructure as a coding problem allows agents to utilize standard language features like typing, OOP encapsulation, and static type-checkers to verify infrastructure logic before execution.
- [12:26](https://www.youtube.com/watch?v=P4PpoTH9ADc&t=746s) Declarative IaC engines provide critical safety guardrails by projecting infrastructure into code space for AI edits, showing plan/diff previews, and lowering validated code back into provider API calls.
- [15:55](https://www.youtube.com/watch?v=P4PpoTH9ADc&t=955s) Modeling infrastructure as code enables access to the full modern software development ecosystem, including package managers (PyPI/npm), linting, and test-driven development workflows.
- [15:55](https://www.youtube.com/watch?v=P4PpoTH9ADc&t=955s) Modern frontier AI workloads demand unprecedented infrastructure scaling, ranging up to multi-gigawatt data center footprints and dynamic multi-cloud compute allocation.
- [18:51](https://www.youtube.com/watch?v=P4PpoTH9ADc&t=1131s) Leading technology platforms and AI labs demonstrate the power of code-based infrastructure, with Wiz handling over 100,000 deployments daily and Composable AI running 100% agentically managed infrastructure.
- [20:26](https://www.youtube.com/watch?v=P4PpoTH9ADc&t=1226s) Over 20% of customer infrastructure deployments observed by Pulumi are already agentically managed.
- [20:26](https://www.youtube.com/watch?v=P4PpoTH9ADc&t=1226s) Autonomous infrastructure management is deployed based on risk profiles, where low-risk operational tasks like waste cleanup and compliance fixes are fully automated, while production deployments remain human-assisted.
## Detailed walkthrough
### [00:04](https://www.youtube.com/watch?v=P4PpoTH9ADc&t=4s) The 2026 Developer Velocity Dilemma
Engineers in 2026 are writing more code than ever before, driven by the rapid evolution of large language models. Development teams have already experienced 2x to 10x gains in application shipping velocity and are well on a trajectory toward a 100x multiplier. This surge is powered by autonomous teams of AI agents working around the clock to draft, refine, and ship application code. Human engineers can now produce the equivalent of multiple compilers per month, progressively relinquishing control as models handle heavy lifting with remarkable quality and correctness.
However, a serious imbalance has emerged because infrastructure management is failing to keep pace. As developers write more code, they simultaneously understand less of it—a shift that is ultimately positive for productivity, but one that introduces severe operational bottlenecks. Crucially, agentic software development does not eliminate fundamental engineering requirements. System scalability, cost management, security, and compliance remain as vital as ever. Furthermore, as AI models become more powerful, they introduce entirely new security challenges and attack vectors that require rigorous oversight.
- **App Code Velocity Gains**: Currently sitting at 2x–10x improvements, trending toward 100x via 24/7 autonomous agent teams.
- **Developer Productivity Metric**: Engineers are shipping the equivalent of multiple compilers' worth of code per month.
- **Core Unchanging Requirements**: Infrastructure, cost controls, efficiency, scalability, security, and compliance cannot be bypassed by using AI.
---
[01:27](https://www.youtube.com/watch?v=P4PpoTH9ADc&t=87s) Karpathy’s "IKEA Furniture" Analogy and Infrastructure Bottlenecks
In a well-known blog post, Andrej Karpathy described his experience building a menu application where he "vibe coded" the app effortlessly—until he attempted to deploy it. Karpathy likened modern application deployment to assembling IKEA furniture: users receive a box of disparate building blocks and torque wrenches, left entirely on their own in a DIY scramble to figure out assembly. Configuring cloud consoles, managing API keys, separating development and production environments, handling secrets, and manually copy-pasting configurations across various interfaces represent a friction-heavy workflow that AI agents simply do not handle well.
Because LLM code-generation throughput is exploding, the primary engineering bottleneck is no longer writing source code. Instead, the real constraints are having good ideas, maintaining good taste, and dealing with the manual friction of "assembling the IKEA furniture"—getting the written code deployed to production. This manual operational overhead includes toggling settings in cloud consoles, passing around credentials, and wrangling YAML files, turning everything outside of code into the primary obstacle.
- **The IKEA Analogy**: Modern app deployment mimics self-assembly furniture—fragmented components, manual tools, and endless DIY configuration.
- **Operational Friction Points**: Cloud console navigation, dev/prod separation, secret distribution, API key generation, and copy-pasting settings.
- **Shift in Bottlenecks**: Writing code is no longer the rate-limiting step; execution, taste, and infrastructure deployment now throttle shipping speed.
---
[03:09](https://www.youtube.com/watch?v=P4PpoTH9ADc&t=189s) The Evolution of IaC: From Manual Steps to Real Code Space
Reflecting on the history of infrastructure management, the industry has transitioned through distinct operational eras. Years ago, operations were entirely imperative and manual—engineers pointed and clicked through cloud consoles, ran one-off CLI commands, and followed static runbooks. This phase was error-prone, unrepeatable, and fragile. The industry then shifted into the configuration era, which marked the birth of Infrastructure as Code (IaC) with tools like Ansible, Terraform, SaltStack, and eventually Kubernetes with its YAML-based declarative dialects. While an improvement, this era amounted to "infrastructure as text" rather than genuine code.
Pulumi was founded nearly ten years ago to make infrastructure management truly ergonomic for humans by expressing declarative infrastructure directly within real programming languages. What began as a human ergonomics effort has turned out to be a massive "happy accident" for AI enablement: what is ergonomic for human developers is equally ergonomic for autonomous agents. Transitioning from text configuration to real programming languages represents one of the largest unlocks for reaching a state of fully agentic infrastructure, shifting developers from simple "vibe coding" into holistic "vibe engineering"—where coding, testing, deployment, and operational management are unified under one programmatic umbrella.
- **Era 1 (Manual)**: Imperative, point-and-click cloud consoles, manual CLI execution, runbooks, and unrepeatable steps.
- **Era 2 (Configuration/Text)**: Declarative text dialects like Ansible, Terraform, SaltStack, and Kubernetes YAML.
- **Era 3 (Code Space)**: Expressing declarative infrastructure using real, full-featured programming languages (e.g., Python, TypeScript, Go).
- **Vibe Engineering**: Expanding beyond raw code generation ("vibe coding") to cover the entire lifecycle of testing, deployment, and production management.
---
[04:43](https://www.youtube.com/watch?v=P4PpoTH9ADc&t=283s) Benchmarks, Scaling Laws, and In-Distribution Training
The scaling laws of large language models continue to hold across frontier models like Meta’s Llama family, Anthropic’s Claude (including Opus 4.7), OpenAI’s GPT series, and open-source models like Qwen and Kimi. These scaling laws translate exceptionally well to software engineering because code is heavily "in-distribution" across training datasets. Millions of developers have spent decades writing hundreds of billions of lines of code and proactively documenting their reasoning in comments, READMEs, and Markdown files. Unlike domains such as medicine—where clinical decisions and surgical procedures are rarely published line-by-line on the public web—software engineering data is abundantly available for training, fine-tuning, and reinforcement learning with human and AI feedback (RLHF/RLAIF). Furthermore, code execution provides a deterministic, verifiable reward signal that helps agents self-correct.
The rapid trajectory of software engineering benchmarks illustrates this acceleration. Less than two years ago (a span of just 21 months), the standard SWE-bench evaluation sat at a meager 33%. Today, frontier models achieve 86% on SWE-bench—representing a 75% error reduction in under two years. High-end models like Anthropic's Mythos already reach 94%, with expectations that most frontier models will exceed 95% on SWE-bench by the end of 2026. This dramatic reduction in error rates allows teams to offload increasingly complex programming problems to agents with high confidence.
- **SWE-bench Progression**:
- ~2024: 33% resolution rate.
- Mid-2026: 86% resolution rate (75% error reduction over 21 months).
- Mythos / High-end Frontier: 94%–95%+ target by end of 2026.
- **Why Code Excels in AI**: Hundreds of billions of lines of public code, self-documenting human text (comments, Markdown), and deterministic execution for RL reward signals.
- **In-Distribution Advantage**: Models naturally excel at coding because their pre-training and fine-tuning datasets are saturated with real-world source code.
---
[07:07](https://www.youtube.com/watch?v=P4PpoTH9ADc&t=427s) The Agentic Infrastructure Gap and the In-Context Fallback
Despite huge advances in writing application logic, infrastructure automation remains severely lagging because standard operational practices are "out-of-distribution" for LLMs. There is no large-scale training signal for clicking buttons in AWS or Azure web consoles, generating API keys, executing manual provisioning scripts, or maintaining scattered YAML glue. This data asymmetry creates a massive gap: models have processed hundreds of billions of lines of general-purpose programming languages, but almost no structured data depicting how human engineers navigate cloud dashboards or glue disjointed operations together.
When skills, tools, or domain practices are out-of-distribution, engineers often try to compensate by inserting information into the prompt via context windows, tool definitions, Model Context Protocol (MCP) servers, or external documentation files. However, if a task is neither in-distribution (learned during pre-training) nor fully provided in-context, models inevitably degrade: they fail or hallucinate. In autonomous systems, hallucination is "the antithesis to full autonomy." The solution is to reframe the problem entirely—instead of teaching models obscure, custom infrastructure workflows, express infrastructure tasks directly as standard coding problems in languages the LLM already knows fluently.
- **The Infrastructure Gap**: High fluency in application code vs. low fluency in manual cloud procedures and custom DSLs.
- **Out-of-Distribution Pitfalls**: Lack of uniform training signals for manual console steps or ad-hoc runbooks leads to hallucinations.
- **The Autonomy Rule**: "Hallucination is the antithesis to full autonomy."
- **The Core Reframe**: Turn infrastructure problems into standard coding problems so LLMs can process them natively using their existing language fluency.
---
[10:58](https://www.youtube.com/watch?v=P4PpoTH9ADc&t=658s) Infrastructure as Code Primitives in Action
When infrastructure is modeled as code, complex deployments are defined using familiar software engineering patterns like object-oriented encapsulation, typed arguments, and control structures. Joe Duffy demonstrates this using a Python example that provisions an ML training cluster—specifically a reinforcement learning (RL) fleet leveraging NVIDIA Blackwell GPUs on CoreWeave cloud infrastructure. The underlying platform resources (such as Kubernetes clusters, NVIDIA operators, and Kubeflow scheduling components) are wrapped inside a reusable Python class, exposing clean, typed interfaces to the user.
On the consumption side, instantiating this infrastructure requires only a few lines of standard Python code. A developer can declare an RL stack, specify the desired GPU types and node counts, and use basic `for` loops to spin up a high-performance cluster featuring one learner node alongside eight rollout worker nodes. By projecting infrastructure concepts into standard language primitives—turning resources into objects, dynamic configurations into typed parameters, and repetitive boilerplate into clean abstractions—agents can leverage type-checkers, compilers, and static analysis tools to verify their work before anything is actually executed.
```python
# Conceptual representation of the Python IaC snippet shown in the talk
class TrainingCluster(ComponentResource):
rollout_workers = [
rl_stack.create_worker(
id=i, gpu_type="Blackwell-L40"
) # Loop constructs for dynamic fleets
for i in range(8)
]
```
- **CoreWeave & Blackwell GPU Example**: Provisioning an RL stack using Python to instantiate 1 learner node and 8 rollout worker nodes.
- **Language Primitives vs. Infra Concepts**:
- Infrastructure Resources $\rightarrow$ Programming Language Objects
- Raw Config Files / YAML $\rightarrow$ Strongly Typed Function Arguments & Variables
- Copy-Pasted Snippets $\rightarrow$ Encapsulated Classes & Reusable Functions
- **Verification Tools**: Agents can run native language type-checkers (e.g., `mypy`) to detect errors ("red squiggles") prior to deployment.
---
[12:26](https://www.youtube.com/watch?v=P4PpoTH9ADc&t=746s) Guardrails, Diffs, and Lowering Code to Infrastructure Space
Generating code is only half the battle; autonomous agents require strict guardrails to operate safely in production. Infrastructure as Code provides a deterministic mechanism to run dry-run previews and generate execution plans before making live changes. If an agent modifies a script to scale up an RL fleet prior to a model release—increasing learner nodes from 4 to 8 and rollout nodes from 8 to 16—the system renders a clear `git diff` alongside an IaC preview step. This allows both human operators and LLM agents to evaluate the exact blast radius of a change before committing it.
This workflow projects "infrastructure space into code space." Agents perform their reasoning, edits, and refactoring inside code space—an environment where they possess world-class fluency. Once the code changes are validated, the declarative IaC engine lowers those representations back down to infrastructure space, executing the physical provider API calls safely. Operating without this abstraction—such as having an agent issue ad-hoc imperative CLI commands or directly poke around cloud consoles—lacks diff previews, state auditing, and rollback capabilities, making true infrastructure autonomy far too dangerous.
- **Plan & Preview Mechanism**: Previewing a hypothetical deployment to evaluate state changes (e.g., scaling learner nodes 4 $\rightarrow$ 8 and rollout nodes 8 $\rightarrow$ 16).
- **Code Space to Infrastructure Space**:
1. Project cloud topology into programming languages (**Code Space**).
2. Let AI agents edit, type-check, and reason about the code natively.
3. Declarative IaC engine lowers validated code changes into provider API actions (**Infrastructure Space**).
- **Agent Safety**: Provides an audit trail, structural guardrails, and explicit approval checkpoints equivalent to a `git diff` for physical cloud resources.
[15:55](https://www.youtube.com/watch?v=P4PpoTH9ADc&t=955s) Standardizing Quality and Scaling Through Code
Modeling infrastructure using real programming languages unlocks the entire modern software development toolchain. Concepts like classes and functions allow developers to structure their architectures cleanly. Sharing and reuse move from copy-pasted configuration files to proper modules and packages, enabling engineers to publish reusable components to standard repositories like PyPI for Python or npm for TypeScript. Dependencies, versioning, and package managers make auditing old versions and rolling out updates structured and predictable, providing full preview capabilities before changes land in production. Furthermore, standard testing frameworks, static analysis, and linters bring rigor to infrastructure management. This test-oriented approach directly complements agentic workflows: when running autonomous coding setups, developers frequently instruct the AI agent to write a failing test first, make the necessary fix, and then prove that the test passes.
Code also scales effortlessly as operational complexity increases. Looking back 15 to 20 years, simple two-tier applications consisting of two virtual machines and a database were static and homogeneous, making basic DSLs or static configuration files sufficient. However, modern architectures rely heavily on containers, serverless functions, and interconnected services spread across complex environments. Distributed computing—a domain the speaker worked on throughout the 2000s during the multi-core processor era—has culminated in the cloud era, placing infinite compute and dynamic data management at developers' fingertips. Expressing these dynamic systems programmatically is the only way to fully utilize them. This requirement becomes even more pronounced in the AI-native era, where workloads demand 2-gigawatt to 5-gigawatt data centers, highly dynamic GPU allocation, and cross-cloud architectures where teams grab available compute wherever they can find it.
- Reusable infrastructure packages can be published directly to standard language registries like PyPI or npm.
- Modern software quality tools like linters, static analyzers, and unit tests apply seamlessly to infrastructure-as-code.
- Historical cloud setups consisted of static two-tier environments (e.g., two VMs and a database), whereas modern setups require composing dozens of dynamic resources per application.
- Current frontier AI demands massive, power-intensive infrastructure scaling up to multi-gigawatt data center footprints.
[18:51](https://www.youtube.com/watch?v=P4PpoTH9ADc&t=1131s) Real-World AI Scale and Customer Success Stories
Working with cutting-edge companies across various sizes highlights how crucial code-based infrastructure has become. For instance, a top-three frontier AI lab scaled its training and inference infrastructure nearly tenfold within a single year—an achievement that would have been impossible using legacy configuration approaches. Security platform Wiz manages over one million cloud resources and achieves a staggering 100,000+ deployments per day. This incredible velocity is powered by embedding infrastructure code directly inside software systems to handle deployments programmatically, setting the stage for future AI agents to manage these operational pipelines end-to-end.
Similarly, Supabase leveraged this code-first approach to ride the "AI tsunami," standing up entirely new cloud regions in less than a week. Startup Composable AI operates with 100% agentically managed infrastructure; while keeping a human in the loop for oversight, they unleash AI agents on all internal infrastructure tasks, allowing a lean, tight team to punch far above its weight. Despite operating at vastly different scales, all these organizations share a single common principle: it is "code all the way down."
- A top-three frontier AI lab scaled training and inference infrastructure by nearly 10x in a single year using code-based management.
- Wiz handles over 1,000,000 cloud resources and performs more than 100,000 deployments every day through automated systems.
- Supabase can deploy and stand up an entirely new geographic cloud region in under a week.
- Composable AI operates an infrastructure stack managed 100% by AI agents with a human in the loop.
[20:26](https://www.youtube.com/watch?v=P4PpoTH9ADc&t=1226s) The Autonomous Future of Agentic Infrastructure
Current usage trends indicate that over 20% of all infrastructure deployments observed across Pulumi's customer base are already agentic. Just as Anthropic CEO Dario Amodei predicted that software engineering would eventually become fully automated, infrastructure management is following the exact same trajectory toward 100% agentic control. Achieving this vision relies entirely on framing infrastructure as a software engineering problem that frontier LLMs can reason about natively.
The path toward full autonomy requires careful evaluation of risk versus reward. Fully autonomous workflows are already viable in low-risk scenarios; for example, Pulumi runs AI agents that automatically delete waste and orphaned resources in internal development accounts, saving thousands of dollars per day even if an occasional accidental deletion occurs. Similarly, agents can proactively tag untagged resources or remediate dormant security compliance issues. In contrast, high-stakes tasks like deploying to production or standing up entire projects remain human-assisted, while mid-tier operational decisions—such as autoscaling environments—benefit from supervised human approval before execution. Ultimately, self-managing teams of AI agents will take over routine infrastructure maintenance, freeing human engineers to focus exclusively on high-value activities.
- Over 20% of customer infrastructure deployments on Pulumi are already driven by AI agents.
- Speaker references Dario Amodei's prediction regarding the eventual complete automation of software engineering to context-set infrastructure trends.
- Automated cleanup agents in development accounts save "thousands of dollars per day" by autonomously pruning unused cloud resources.
- Operational tasks are categorized into autonomous (waste cleanup, resource tagging, compliance fixes), supervised (autoscaling changes), and human-assisted (production deployments, new infrastructure projects).
## Notable quotes
> [01:27](https://www.youtube.com/watch?v=P4PpoTH9ADc&t=87s) vibe coding — Andrej Karpathy
> [01:27](https://www.youtube.com/watch?v=P4PpoTH9ADc&t=87s) assembling IKEA furniture — Andrej Karpathy
> [03:09](https://www.youtube.com/watch?v=P4PpoTH9ADc&t=189s) vibe engineering — Joe Duffy
> [07:07](https://www.youtube.com/watch?v=P4PpoTH9ADc&t=427s) hallucination is the antithesis to full autonomy
> [18:51](https://www.youtube.com/watch?v=P4PpoTH9ADc&t=1131s) code all the way down
## Mentioned
Joe Duffy, Pulumi, Andrej Karpathy, IKEA, Ansible, Terraform, SaltStack, Kubernetes, YAML, Llama, Meta, Claude, Anthropic, Opus 4.7, GPT, OpenAI, Qwen, Kimi, SWE-bench, Mythos, Model Context Protocol (MCP), AWS, Azure, Python, TypeScript, Go, CoreWeave, NVIDIA, Blackwell, Kubeflow, PyPI, npm, Wiz, Supabase, Composable AI, Dario Amodei
Joe Duffy argues that as autonomous AI agents accelerate application code generation, cloud deployment has become the primary operational bottleneck because manual console workflows and fragmented configuration formats are out-of-distribution for large language models. Resolving this gap requires expressing infrastructure as standard code in general-purpose programming languages, enabling models to leverage existing language fluency, static verification tools, and declarative guardrails.
The Post-Coding Deployment Bottleneck (1:27)
Engineering teams are seeing two- to tenfold velocity gains in application code, with Duffy forecasting a trajectory toward a hundredfold increase as 24/7 autonomous agents draft and ship software. However, infrastructure operations have failed to keep pace. Referencing an analogy by Andrej Karpathy, Duffy compares contemporary deployment to assembling IKEA furniture: engineers are left with disconnected components, manual cloud console configurations, API keys, secret management, and brittle environment setups.
Because language models have made code authoring abundant and fast, writing source code is no longer the critical bottleneck in software delivery. Instead, the rate-limiting factor has shifted to operational friction—navigating dashboards, passing credentials, and wrangling disparate configuration files to safely run code in production.
In-Distribution Code Versus Operational Hallucination (7:07)
Frontier models excel at software engineering because code is heavily in-distribution across training data, supported by hundreds of billions of lines of public source code, comments, and deterministic execution feedback. Benchmark performance reflects this strength, with SWE-bench resolution rates rising from 33% to 86% over 21 months, and high-end models targeting over 95% by the end of 2026.
In contrast, manual cloud console navigation and ad-hoc YAML glue lack large-scale pre-training signals, making them out-of-distribution tasks prone to hallucination. Because Duffy views hallucination as the antithesis of autonomy, relying on context windows or ad-hoc runbooks cannot close the reliability gap. The practical solution is re-framing infrastructure operations as standard coding problems in languages models already master natively.
Language Primitives, Static Checks, and Guardrails (12:26)
Expressing infrastructure through programming languages like Python or TypeScript allows complex topologies—such as CoreWeave Kubernetes clusters powering NVIDIA Blackwell GPU fleets—to be packaged into reusable classes, typed arguments, and standard control structures. This allows autonomous agents to employ native linters, test suites, and type-checkers like mypy to catch configuration errors before deployment, while leveraging package managers such as PyPI and npm for distribution.
Crucially, this approach projects cloud topology into code space, where agents reason and refactor, before a declarative engine lowers those changes to provider APIs. Dry-run previews and execution plans act as a git diff for physical infrastructure, establishing explicit blast-radius boundaries and audit trails that prevent agents from executing destructive imperative commands directly against live environments.
Real-World Adoption and Risk-Tiered Autonomy (20:26)
Programmatic infrastructure management already underpins hyper-scale operations: security platform Wiz handles over 100,000 daily deployments across more than one million cloud resources, and a top-three frontier AI lab expanded its infrastructure tenfold in a single year. Duffy reports that over 20% of deployments across Pulumi's customer base are currently executed by AI agents.
Rather than attempting unconstrained automation, production adoption relies on risk-tiered delegation. Low-risk background tasks—such as agents pruning orphaned resources in internal development accounts, which saves thousands of dollars daily, or remediating compliance tags—operate fully autonomously. Medium-risk operations like autoscaling require supervisory sign-off, while high-stakes actions like spinning up greenfield environments and production deployments remain human-assisted.
Duffy anticipates infrastructure operations moving toward comprehensive agentic management, paralleling broader industry forecasts of automated software engineering. Achieving reliable autonomy across increasingly complex, multi-gigawatt AI infrastructure ultimately hinges on keeping operational tasks inside typed, verifiable code spaces backed by deterministic preview and approval guardrails.
## Background
该视频由 YouTube 频道 @Scale 于 2026 年 6 月 26 日发布，记录了 Pulumi 创始人 Joe Duffy 在 @Scale 大会上的演讲。演讲围绕 AI 时代的基础设施瓶颈展开，探讨如何通过通用编程语言将复杂繁琐的基础设施问题转化为大语言模型最擅长解决的代码编写问题，从而迎接由智能体自主管理基础设施的未来。
## TL;DR
随着智能体编码让应用代码产出效率暴增数倍乃至百倍，软件交付的全新瓶颈转移到了除代码之外的一切基础设施与运维泥潭——正如 Karpathy 所喻的“拼装宜家家具”。传统基础设施的配置、点选与专用 DSL 处于大模型训练分布之外，导致智能体极易幻觉和出错；Pulumi 主张利用 Python、TypeScript 等分布内（in-distribution）通用编程语言将基础设施空间完整投影到代码空间。通过类型检查、Git Diff 和执行预览机制建立可靠护栏，业界正从监督式的开发环境清理逐步过渡到高吞吐、大规模的完全智能体化基础设施编排。
## Atmosphere & style
演讲整体呈现出前瞻、务实且充满极客洞察的技术分享氛围，Joe Duffy 娓娓道来，既有对当前工程痛点的敏锐剖析，也有对云原生架构演进的宏大视野。从引用 Karpathy 拼装宜家家具的诙谐隐喻，到展示 CoreWeave 与 Blackwell 集群的代码实操，情绪曲线上兼具清醒的工程审慎与对 AI 自治前景的激昂共鸣。整场演讲信息密度极高，给听众带来一种置身技术范式变革前沿、亲历运维体系底层逻辑被重塑的震撼感与笃定感。
## Bulletin
- [00:04](https://www.youtube.com/watch?v=P4PpoTH9ADc&t=4s) 大模型驱动的应用代码交付速度已实现 2 至 10 倍跃升并迈向 100 倍，但软件开发的瓶颈已全面转移至除编写代码之外的基础设施与云端部署环节。
- [04:42](https://www.youtube.com/watch?v=P4PpoTH9ADc&t=282s) 通用编程语言处于大模型的海量分布内（In-distribution），而传统云控制台点选与零散 YAML 文本配置处于分布外，导致智能体极易产生幻觉与运维失败。
- [09:44](https://www.youtube.com/watch?v=P4PpoTH9ADc&t=584s) 将基础设施全面映射为 Python 等现代代码，使智能体能够依托类型系统、静态检查与预览对比（Preview/Plan）构建确定性与安全的闭环验证机制。
- [20:26](https://www.youtube.com/watch?v=P4PpoTH9ADc&t=1226s) 当前已有超过 20% 的 Pulumi 基础设施部署由智能体自主驱动，行业正通过风险收益分级在开发环境清理、合规治理等场景率先迈向自主运维。
## Key takeaways
- [00:04](https://www.youtube.com/watch?v=P4PpoTH9ADc&t=4s) AI 辅助编程让单月代码产出达到编译器体量，但可扩展性、安全攻击面及成本管控等基础设施需求反而更严苛。
- [01:27](https://www.youtube.com/watch?v=P4PpoTH9ADc&t=87s) 当前软件研发现状如同组装宜家家具，代码生成吞吐暴增使得限制效率的核心痛点变为除代码外的一切运维环境落地。
- [02:42](https://www.youtube.com/watch?v=P4PpoTH9ADc&t=162s) 基础设施演进经历了手动点击、静态文本配置（IaT）到通用编程语言（IaC），而对人类工效学友好的通用语言同样天然契合 AI 智能体。
- [04:42](https://www.youtube.com/watch?v=P4PpoTH9ADc&t=282s) 互联网沉淀了数千亿行带文档的高质量代码与编译器反馈，使得通用语言在 SWE-bench 上表现突飞猛进，远优于缺乏训练信号的私有 DSL 与分散运维操作。
- [09:44](https://www.youtube.com/watch?v=P4PpoTH9ADc&t=584s) 解决智能体运维幻觉的关键并非强行训练非标 DSL，而是把基础设施挑战直接重构成模型原生精通的代码编写问题。
- [10:58](https://www.youtube.com/watch?v=P4PpoTH9ADc&t=658s) 利用 Python 原生类和循环即可高度封装 CoreWeave 集群及 NVIDIA Blackwell GPU 运行时，以十余行代码完成动态强化学习算力拓扑声明。
- [12:26](https://www.youtube.com/watch?v=P4PpoTH9ADc&t=746s) IaC 的 Preview/Plan 变更预览机制构成了智能体与物理硬件间的隔离防线，使智能体能够在落地部署前自主校验意图与拓扑影响。
- [14:52](https://www.youtube.com/watch?v=P4PpoTH9ADc&t=892s) 将云端物理资源映射为强类型对象与语言包，使得面向对象抽象、包版本管理和测试驱动开发（TDD）等现代工程方法能够无缝复用到基础设施中。
- [16:59](https://www.youtube.com/watch?v=P4PpoTH9ADc&t=1019s) 面对未来 2 到 5 吉瓦（GW）级别的异构 AI 算力中心与跨云极速调度，传统静态配置无法承载，唯有具备动态表现力的真实编程语言才能胜任。
- [18:57](https://www.youtube.com/watch?v=P4PpoTH9ADc&t=1137s) 前沿 AI 实验室与 Wiz 等独角兽通过代码化基础设施实现了单日超 10 万次部署，将算力规模在一年内扩容 10 倍，证实了全软件驱动交付的可行性。
- [20:58](https://www.youtube.com/watch?v=P4PpoTH9ADc&t=1258s) 基础设施智能体化正遵循风险收益权衡稳步落地：在低风险的开发环境闲置清理与资源打标中已完全自主，而在核心生产环境仍采用人机监督与辅助机制。
## Detailed walkthrough
### [00:04](https://www.youtube.com/watch?v=P4PpoTH9ADc&t=4s) 2026 年的代码暴增与“落后的基础设施”瓶颈
在 2026 年，工程师编写的代码量比以往任何时候都要庞大，这一现象令人震撼。得益于大语言模型（LLM）及其性能的持续提升，业内见证了应用代码交付速度实现了 2 到 5 倍、乃至 10 倍的飞跃；随着自主运作的智能体团队（Teams of agents）全天候不间断地编写应用代码，交付速度正迈向 100 倍。然而，基础设施却远远未能跟上这种爆炸式的节奏。与此形成奇妙对照的是，工程师对正在编写的代码的细节理解却比以往更少。
这听起来似乎令人担忧，但实际上是一件好事：随着智能体能力的增强，人类正将更多控制权移交给它们，不再需要为底层代码疲于奔命。人类能够放心地依赖智能体编写大量高质量、正确无误的代码——如今单个工程师一个月内产出的代码量，甚至相当于以往多个编译器的规模。但在光鲜的背后，新的瓶颈已经出现。采用智能体编码（agentic coding）并不会让基础设施的需求凭空消失；系统仍然需要保持高效可扩展、需要成本控制、安全防范与合规治理。事实上，随着模型能力的提升，安全攻击面与新型向量反而在持续增加。
- 交付效率已实现 2x 至 10x 跃迁，未来在多智能体团队协作下预计可达 100x。
- 工程师正在从底层细节中抽身，月均产出等同于以往编写多个编译器的体量。
- 基础设施、成本管控、合规性与安全性依旧不可或缺，且伴随更强大的模型迎来了全新安全挑战。
---
### [01:27](https://www.youtube.com/watch?v=P4PpoTH9ADc&t=87s) 卡帕西的隐喻：现代应用就像“拼装宜家家具”
Andrej Karpathy 曾写过一篇引人深思的博文，讲述他通过“氛围编码”（vibe coding）构建一款菜单应用的经历：在编写代码的过程中一切流畅愉悦，可一旦进入上线部署环节，现实便迎头痛击。Karpathy 将构建现代应用比作“组装宜家家具”——零件和积木散落一地，用户拿着扭矩扳手，只能全靠 DIY 自己摸索组装。
面对纷繁复杂的云服务配置、API 密钥管理、测试环境（dev）与生产环境（prod）隔离、凭证保据，以及全网四处复制粘贴配置，智能体表现得极不擅长。这就形成了全新的技术瓶颈：AI 负责写代码，代码编写的吞吐量空前暴涨，使得“编写代码”本身已不再是限制研发效率的卡点；现在的真正难点变成了拥有好点子、保持好品味，以及把那套散落的“宜家家具”组装成型——让代码在它该运行的地方平稳运行。现阶段的部署涉及大量人工介入：进入云控制台、手工分配 API 密钥、到处搬运 YAML 文件。正如 Joe Duffy 所总结，**现在的瓶颈已经变成了除代码之外的一切（everything but the code）**。
```mermaid
flowchart TD
accTitle: 现代应用部署的瓶颈转移
accDescr: 展示从以往的代码瓶颈向当前除代码外的一切运维瓶颈的演变过程。
subgraph Speed["高速增长端：代码层"]
A["智能体自主编码"] --> B["吞吐量激增 10x - 100x"]
B --> C["编写代码不再是瓶颈"]
end
subgraph Friction["迟滞受阻端：基础设施层"]
D["云控制台点选"]
E["API 密钥与凭证流转"]
F["复制粘贴 YAML 胶水代码"]
end
C -.->|"遇到现实墙壁"| G["宜家组装式运维困境"]
D --> G
E --> G
F --> G
G --> H["全新瓶颈：基础设施与运行落地"]
```
---
### [02:42](https://www.youtube.com/watch?v=P4PpoTH9ADc&t=162s) 从文本到代码：Pulumi 的演进与“氛围工程”的觉醒
回顾基础设施管理的演进史，Joe Duffy 回顾了近十年前创立 Pulumi 时的初衷：为人类开发者打造符合工效学（ergonomic）的基础设施即代码。基础设施的管理模式先后经历了多个阶段：
1. **纯手工阶段**：管理员在云控制台鼠标点选、运行手写 CLI 命令、依赖人工 Runbook。所有的操作完全是命令式（imperative）的，全手工进行，过程不仅不可复现，而且极易出错。
2. **配置文件阶段**：Ansible、Terraform、SaltStack 乃至 Kubernetes 的 YAML 规范相继诞生。虽然这被称为“基础设施即代码”（IaC），但实质上只是“基础设施即文本”（Infrastructure as Text），表达力受限于静态文本。
3. **真实编程语言阶段**：Pulumi 等探索使用完整的现代编程语言来表达基础设施，在保留声明式管理特性的同时，获得了通用语言完整的抽象与表达能力。
令人惊喜的“意外收获”（happy accident）在于：**对人类工效友好（ergonomic）的设计，同样对 AI 智能体高度友好**。这成为开启完全智能体化基础设施（fully agentic infrastructure）的关键钥匙。人类正在从“氛围编码”（vibe coding）跨入“氛围工程”（vibe engineering）——写代码只是冰山一角，工程涉及对整个系统的工程化构建，涵盖编码、测试、部署以及生产环境全生命周期的维护管理。2026 年软件开发真正的瓶颈，早已由编码转向了这背后的“一切其他环节”。
---
### [04:42](https://www.youtube.com/watch?v=P4PpoTH9ADc&t=282s) 训练集不对称：分布内与分布外的鸿沟
模型能力的持续爆发源于 Scaling Law（缩放定律）的有效成立。从 Meta 的全新 Spark 2、Anthropic 的 Claude Opus 及最新的 Opus 4.7，到 GPT-5.5 以及开源界的 Qwen、Kimi，模型综合实力突飞猛进。这种缩放定律在“代码编写”领域体现得尤为极致，究其原因：
- 互联网上存在数以千亿行计的高质量代码资源（GitHub、Stack Overflow 等）。
- 软件工程领域有着独特的文化：开发者倾向于在 Markdown 文档中、代码注释中主动自我记录“正在做什么以及为什么这么做”。这与医学等行业有着本质不同——医生在进行诊断和手术时，不可能将每一条微小推论与操作细节全都整理成文并公开到互联网供模型吸收。
由于海量通用编程语言处于模型的**分布内（in-distribution）**，智能体天生擅长编程。在权威软件工程评测集 SWE-bench 上，不到两年前（短短 21 个月内），成绩仅为 33%，而到了当下最新的前沿模型已攀升至 86%，错误率骤降 75%；Anthropic 的 Mythos 模型更已斩获 94% 的成绩，预计 2026 年底前沿模型将普遍达到 95% 以上，再降低 64% 的错误。
然而，基础设施领域却远远落后。过去的各种运维方式全部处于**分布外（out-of-distribution）**：
- 控制台的点选点击、API 密钥的手工流转、零散的 YAML 胶水代码，在互联网上几乎没有统一规范的训练信号。
- 信号量存在巨大的数量级不对称：数千亿行 Python、TypeScript、Go 的结构化代码，对比极度离散、缺乏统一模式的临时运维操作。
- 通用代码具备天然的正确性验证手段，能够通过测试用例和编译器提供确定性的执行反馈，直接充当强化学习（RL）流水线中的奖励信号（reward signal）；而随意执行的命令行与文本配置难以验证，高度漫散。
当特定领域既不在模型的“预训练分布”（distribution）中，也无法放入“上下文窗口”（context，如利用 Skills、MCP 协议服务器或工具将相关信息注入上下文）时，模型面对这类基础设施任务便只会彻底崩溃或胡乱猜测。若要攻克这一僵局，核心出路正是将基础设施问题重新转化为标准的编程问题。
### [09:44](https://www.youtube.com/watch?v=P4PpoTH9ADc&t=584s) 范式转换：将基础设施挑战重构成代码问题
幻觉是通向完全自主智能体（Full Autonomy）的死敌。当大模型遇到不熟悉的私有运维惯例或口口相传的运维流程时，它们注定会产生幻觉并引发不可逆的灾难。面对这一困境，行业内最直觉的反应往往是试图强行教会模型各种非标准的冷门基础设施实践，但 Joe Duffy 提出了一个颠覆性的设问：与其逆流而上，为什么不把基础设施问题直接表述为代码问题，让智能体在它们最为精通的母语中去解决？这正是 Pulumi 对基础设施即代码（IaC）的核心主张——彻底摒弃手工作业与脱离模型分布的自研领域特定语言（DSL），直接拥抱人类与大模型都早已融会贯通的真实编程语言。
这种转向不仅兼顾了人类与机器的代码人体工学（Ergonomics），更完整继承了传统 IaC 最关键的内核特质：声明式定义、事前可预测性、完备的审计能力与可控性。在智能体自主运维的时代，护栏（Guardrails）成了生命线。工程师必须通过严谨的架构构造，确保智能体清晰地知道自己在什么边界内运作，并且从物理上无法越界。以代码为底座的 IaC，天然为自主智能体筑起了一道不可逾越的确定性防线。
### [10:58](https://www.youtube.com/watch?v=P4PpoTH9ADc&t=658s) 实战切入：用 Python 编排 CoreWeave 与 Blackwell 强化学习集群
在具体的代码实现层面，复杂的基础设施被完全映射为工程师熟悉的现代 Python 代码。以一个典型的强化学习（RL）集群为例，代码左侧定义了一套运行在 CoreWeave 云平台、搭载最新 NVIDIA Blackwell GPU 的训练集群类。这里利用了标准的面向对象抽象，把 CoreWeave Kubernetes 集群以及底层的 NVIDIA AI 运行时堆栈完整封装起来，隐藏了配置 NVIDIA GPU Operator 和用于 GPU 调度的 Kubeflow 等繁杂琐碎的技术细节。
而在消费端，原本极其恐怖的基础设施搭建被极度简化。在右侧的主逻辑中，工程师仅用十几行代码就拉起了一整套动态强化的强化学习训练舰队：一个配置极高算力 GPU 的 Learner（学习节点），配合一个简单的 Python `for` 循环批量派生出的 8 个 Rollout Workers（采样工作节点）。"仅仅十二行代码，我们就利用业界顶尖的云服务与 GPU 硬件搭建出了高度动态的强化学习集群。" 这种用循环、类和变量直接操作基础设施的能力，仅仅是问题代码化后冰山一角的一瞥。
- **基础设施封装**：利用 Python Class 封装 CoreWeave 集群、NVIDIA GPU Operator 及 Kubeflow 调度器，屏蔽底层异构细节。
- **动态算力拓扑**：通过语言原生的 `for` 循环一键声明 1 个核心 Learner 节点与 8 个 Rollout Worker 节点，轻松指定节点规格与 GPU 架构。
### [12:26](https://www.youtube.com/watch?v=P4PpoTH9ADc&t=746s) 差异对比与执行预览：智能体交互的防翻车机制
然而，直接写代码拉起硬件绝不等于随意的命令式脚本（Imperative Scripting）。IaC 最不可或缺的灵魂，在于它允许系统在执行前提出假设性提问："如果我把这行代码部署上去，实际物理世界究竟会发生什么？" 基础设施的代码化首先带来了原汁原味的 Git Diff。例如，当团队准备发布下一代基础模型并需要扩容 RL 训练环境时，工程师将 Learner 节点从 4 台调整为 8 台，将 Rollout 节点从 8 台扩充为 16 台，这些变更在代码 diff 中一清二楚。
但在高度封装、多层抽象的复杂系统中，仅仅看懂代码行级别的增删，并不总能直观推导最终基础设施拓扑的实际受影响面。这时，IaC 引擎的 Preview/Plan（变更预览）机制便发挥了决定性作用。它精准罗列出 Learner 节点的垂直扩展和新增的 8 个 Rollout 节点，让变更一目了然。对于像 Claude Code 这类智能体编程助手而言，这一机制同样至关重要：
- 智能体修改 `train.py` 中的基础设施声明后，不会盲目敲击物理接口，而是调出预览界面供人机协同审查。
- 智能体通过比对预览输出与原始意图，自主验证实际部署结果是否完全符合既定目标。
- 相比于让智能体直接在控制台调用命令行 CLI "乱戳基础设施"，IaC 提供了完整的状态追踪与审计机制，规避了无审查黑盒操作的致命风险。
```mermaid
flowchart TD
accTitle: 智能体基础设施双循环验证流程
accDescr: 展示智能体在代码空间修改配置后，通过 IaC 引擎预览并映射回基础设施空间的闭环校验逻辑。
subgraph CodeSpace["代码空间 (Code Space)"]
Agent["自主智能体 (如 Claude Code)"]
CodeFile["声明代码 (train.py)"]
GitDiff["代码差异对比 (Git Diff)"]
end
subgraph EngineSpace["IaC 投影引擎 (Pulumi Engine)"]
PlanPreview["变更预览 (Plan / Preview)"]
Verify{"意图与结果校验"}
end
subgraph InfraSpace["基础设施空间 (Infra Space)"]
Apply["确定性部署执行"]
Hardware["云端算力 (CoreWeave / GPU 集群)"]
end
Agent -->|"修改配置参数"| CodeFile
CodeFile --> GitDiff
CodeFile -->|"静态拓扑分析"| PlanPreview
PlanPreview --> Verify
Verify -->|"意图吻合，确认发布"| Apply
Apply --> Hardware
Hardware -.->|"反馈物理状态"| PlanPreview
```
### [14:52](https://www.youtube.com/watch?v=P4PpoTH9ADc&t=892s) 维度映射：将基础设施空间全量投射至代码空间
从本质架构来看，这种模式的实质是"将物理基础设施空间完整投影至代码空间"（Projecting infrastructure space into code space）。大语言模型最擅长编写代码，而 IaC 引擎则充当了高精度编译器与下沉通道，将代码空间的改动无损降解回物理基础设施空间。在这一映射体系下，过往所有繁琐、易碎的基础设施概念，都找到了对应的现代软件工程原语：
| 传统运维概念 / 痛点 | 代码空间对应的核心原语 | 赋能智能体与软件工程的收益 |
|:--- |:--- |:--- |
| **云端物理资源** | 一等公民对象（Objects） | 面向对象编程，属性与生命周期内聚 |
| **非类型化的杂乱 Config** | 强类型参数与变量（Types） | 享受静态类型检查（Type Checkers）与波浪线语法纠错 |
| **手工复制粘贴配置** | 类与函数（Classes & Functions） | 真正的逻辑复用与干净的组件封装抽象 |
| **缺乏规范的架构共享** | 语言原生包（pip / npm Packages） | 依托公共包管理器进行分发、版本固化与安全审计 |
| **不可控的环境漂移** | 显式依赖版本化（Semantic Versioning） | 通过升级依赖版本号并预览即可完成标准化基线演进 |
| **临时随意的 Ad-hoc 验证** | 单元测试、Lint 与静态分析工具 | 允许智能体先写测试验证架构缺陷，修复后再跑通验证 |
这种投射对于自主智能体是革命性的。在全自主编码的实践中，开发者通常遵循"测试驱动开发"（TDD）：让智能体先写一段失败的测试证明 Bug 存在，修改代码直至测试通过。如今，这套严谨的软件测试闭环终于可以平滑无缝地应用在服务器、网络与集群架构的编排与治理中。
### [16:59](https://www.youtube.com/watch?v=P4PpoTH9ADc&t=1019s) 复杂度跃迁：从两台虚拟机到千兆瓦级 AI 原生集群
代码表达的另一大决定性优势在于其极强的抗复杂性扩展能力（Scales with complexity）——架构负载越艰巨复杂，真实代码展现的威力就越显著。回望十五二十年前的传统单体时代，业界主流不过是"两台虚拟机加一个数据库"的经典双层架构，环境静态、高度同构且极少变动；在那个时期，用简陋的 DSL 或是静态 YAML/JSON 配置文件或许勉强够用。然而，随着微服务、容器化与 Serverless 的全面普及，现代架构充斥着数百个相互交织的动态服务，配置的拓扑复杂度早已不可同日而语。
云计算的本质是分布式计算。当行业步入当前以大模型为核心的 AI 原生时代，系统复杂度更被推向了前所未有的顶峰：
- **超大规模算力基建**：产业界正在设计和规划 2 吉瓦（GW）乃至 5 吉瓦级别的超巨型计算数据中心。
- **极端异构与跨云调度**：企业面临跨云平台的 GPU 混合架构与极其动态的训练/推理作业调度，"只要哪里有可用的 GPU，业务就必须立刻接管那里的算力"。
- **动态编程的必然性**：面对如此极端动态、高度异构且算力渴求无上限的世界，唯有真正的通用编程语言才能承受住这种维度的编排开销，将基础设施的管理彻底转化为智能体与人类都得心应手的代码问题。
### [18:57](https://www.youtube.com/watch?v=P4PpoTH9ADc&t=1137s) 从前沿实验室到独角兽：代码化驱动的极端基础设施落地案例
无论企业规模大小还是团队人数多寡，业界都在构建规模极其惊人、极其酷炫的基础设施架构。Joe Duffy 指出，这种变革覆盖了整个团队与公司规模谱系。Pulumi 曾与全球排名前三的前沿 AI 实验室（Top 3 Frontier Lab）深度合作，在短短一年内将其训练与推理基础设施扩展了近 10 倍。面对这样剧烈的扩张速度，沿用传统的静态配置技术是根本不可能实现的，唯有将基础设施真正编写为可复用、可编程的软件代码，才能支撑起这种指数级的算力膨胀。
另一个极为典型的代表是当红安全独角兽 Wiz。Wiz 管理着超过 100 万项云上资源，更令人瞠目结舌的是，他们每天执行的基础设施部署次数超过 100,000 次。Joe 坦言这种数据连他自己都觉得“疯狂得难以置信”，而这之所以能成为现实，完全是因为当基础设施被抽象为通用代码后，团队能够将其内嵌到其他驱动部署的软件服务中，从而彻底摆脱了依赖人工点击或手动触发流水线的原始模式——而这种“由软件驱动部署”的范式，正是未来全面交由 AI 智能体（Agent）接管部署的天然前置条件。
开源后端巨头 Supabase 同样借着这轮生成式 AI 巨浪顺势而上，如今他们已经能够做到在不到一周的时间内快速交付并上线一个全新的云区域（Region）。而在初创公司一侧，新兴团队 Composable AI 的实践更为激进：他们实现了 100% 由智能体管理基础设施。虽然团队在关键环节仍然保持了严谨的“人机协同”（Human-in-the-loop），但他们敢于将所有基础设施难题直接放手交给智能体去自主解决，凭借一支极其精简干练的极客团队便完成了超乎想象的交付量。尽管这些企业的体量与业务复杂度截然不同，但贯穿始终的唯一底层共识就是：“从头到尾全是代码”（Code all the way down）。
- **前沿 AI 实验室**：仅用一年时间将模型训练与推理基础设施规模提升了近 10 倍。
- **Wiz**：纳管资源超 100 万项，每天系统化执行超过 100,000 次部署。
- **Supabase**：借助可编程基础设施，新开一个可用区域的周期压缩至一周以内。
- **Composable AI**：早期团队即实现 100% 智能体化基础设施管理，以精简人员规模实现高通量产出。
---
### [20:26](https://www.youtube.com/watch?v=P4PpoTH9ADc&t=1226s) 迈向 100% 智能体化：基础设施本质上是代码编写问题
这种以代码为底座的演进已经不再停留在设想阶段。数据显示，在 Pulumi 现有的企业客户实际操作中，已经有超过 20% 的基础设施部署工作是由 AI 智能体自主驱动的。正如 Anthropic 首席执行官 Dario Amodei 先前做出的精准预判——软件编写工作终将全面转向 100% 智能体化，Joe Duffy 坚信云基础设施领域也必然会重走这条道路。通往 100% 智能体管理基础设施的终局已经不可逆转，而开启这扇大门的根本基石，就是将复杂的云资源编排与运维彻底重塑为一个纯粹的“代码编写问题”。
```mermaid
flowchart TD
accTitle: 基础设施智能体化演进路径
accDescr: 展示从代码化基础设施到全自动智能体接管的演进逻辑与应用分级。
subgraph CoreFoundation["核心基石：代码化 (Code Space)"]
A["通用编程语言<br/>(Python / TypeScript / Go)"] --> B["可嵌入软件的编排引擎<br/>(Pulumi)"]
end
subgraph AgenticExecution["智能体介入驱动"]
B --> C["软件自动化触发部署<br/>(如 Wiz 每日 10 万+ 次)"]
C --> D["智能体自主生成与演进代码<br/>(当前占比已超 20%)"]
end
subgraph AutonomySpectrum["分级自治落地"]
D --> E["全自主执行<br/>(测试清理 / 资源打标)"]
D --> F["监督 / 协同执行<br/>(环境弹性扩缩 / 生产发布)"]
end
```
---
### [20:58](https://www.youtube.com/watch?v=P4PpoTH9ADc&t=1258s) 风险收益权衡与自治未来：从清理开发环境到智能体协同
实现完全自治的道路绝非一蹴而就，任何工程团队都不可能在毫无节制的情况下把 AI 智能体直接“放养”进生产云账户中，背后牵涉极其严密的风控考量。然而，在诸多细分工作流中，全自主运行的雏形已经落地生根。以 Pulumi 内部工程实践为例，他们已经完全允许智能体自主清理开发账户（Dev accounts）中的闲置云资源浪费。这种设计背后的核心驱动力在于“风险与收益权衡”（Risk-reward shifts）的转移。
如果智能体在开发环境中误删了一台不该删的机器，后果或许“有点烦人”，但整体可控；而它带来的收益却是实打实的——每天能够替公司节省数千美元的闲置云账单开销。类似的工作还包括主动扫描并补齐缺失的资源标签（Tagging）、静默修复一直处于休眠未修复状态的合规漏洞，在这些场景下，赋予智能体自主权在当下就是收益远大于风险的最优解。
相较之下，在涉及生产环境（Prod）发布或全新基础设施立项等关键路径上，当前依然必须采用“人类辅助”（Human-assisted）模式；而诸如环境自动扩缩容（Auto-scaling）等复杂操作，则更适合“受监督模式”（Supervised），先由智能体制定决策与代码改动，再由人类工程师快速审核确认后执行。展望长远，Joe 坚信最终形态一定是多个互相协作的智能体团队自主接管并治理底层基础设施，从而将人类工程师从机械琐碎的运维泥潭中彻底解放出来，去专注于真正创造业务增值的核心事务中。
- **全自主场景（Autonomous）**：开发环境闲置资源自动回收（每天可挽回数千美元浪费）、自动补齐缺失标签、修复存量合规漏洞。
- **人机监督场景（Supervised）**：集群动态扩缩容决策，由智能体计算编排方案，经人类快速确认后落地。
- **人类辅助场景（Human-assisted）**：生产环境核心架构上线、从零构建全新的跨云绿地项目（Greenfield projects）。
## Notable quotes
> [01:27](https://www.youtube.com/watch?v=P4PpoTH9ADc&t=87s) 现在的瓶颈已经变成了除代码之外的一切（everything but the code）。 — Joe Duffy
> [02:42](https://www.youtube.com/watch?v=P4PpoTH9ADc&t=162s) 对人类工效友好（ergonomic）的设计，同样对 AI 智能体高度友好。 — Joe Duffy
> [10:58](https://www.youtube.com/watch?v=P4PpoTH9ADc&t=658s) 仅仅十二行代码，我们就利用业界顶尖的云服务与 GPU 硬件搭建出了高度动态的强化学习集群。 — Joe Duffy
> [12:26](https://www.youtube.com/watch?v=P4PpoTH9ADc&t=746s) 如果我把这行代码部署上去，实际物理世界究竟会发生什么？ — Joe Duffy
> [14:52](https://www.youtube.com/watch?v=P4PpoTH9ADc&t=892s) 将物理基础设施空间完整投影至代码空间 — Joe Duffy
> [16:59](https://www.youtube.com/watch?v=P4PpoTH9ADc&t=1019s) 只要哪里有可用的 GPU，业务就必须立刻接管那里的算力 — Joe Duffy
> [18:57](https://www.youtube.com/watch?v=P4PpoTH9ADc&t=1137s) 从头到尾全是代码（Code all the way down）。 — Joe Duffy
> assembling IKEA furniture — Andrej Karpathy
## Mentioned
Joe Duffy, Pulumi, Andrej Karpathy, Meta Spark 2, Anthropic Claude Opus, Anthropic Claude Opus 4.7, GPT-5.5, Qwen, Kimi, SWE-bench, Claude Code, CoreWeave, NVIDIA Blackwell, NVIDIA GPU Operator, Kubeflow, Ansible, Terraform, SaltStack, Kubernetes, Wiz, Supabase, Composable AI, Dario Amodei, Model Context Protocol (MCP)
## Video description
Speaker: Joe Duffy from Pulumi
To handle the scale and velocity of AI-written code, we will have no choice but to let AI manage our infrastructure too. Yet Andrej Karpathy recently described getting an app running in production as “assembling IKEA furniture”: cloud consoles, API keys, copy-pasted config, glue, ... all things that sit outside the code an LLM can reason about. Frontier models are trained on billions of lines of real languages like Python, TypeScript, and Go, and vanishingly little bespoke DSLs and manual procedures. By modeling infrastructure in code space so the LLM can do what it does best — code — we just need an oracle that can map code changes back to infrastructure outcomes. In this talk, I’ll share what we’ve learned at Pulumi working alongside leading AI companies and frontier labs to build for a world where agents manage infrastructure. The platforms that win in this new era will look different, but many of the human-ergonomic benefits of programming languages are what will get us there.
Learn more about the @Scale conferences here: atscaleconference.com
[Source](https://www.youtube.com/watch?v=P4PpoTH9ADc)
Source quotes
[1:27] Joe Duffy: 现在的瓶颈已经变成了除代码之外的一切（everything but the code）。
[2:42] Joe Duffy: 对人类工效友好（ergonomic）的设计，同样对 AI 智能体高度友好。
[10:58] Joe Duffy: 仅仅十二行代码，我们就利用业界顶尖的云服务与 GPU 硬件搭建出了高度动态的强化学习集群。
[12:26] Joe Duffy: 如果我把这行代码部署上去，实际物理世界究竟会发生什么？
[14:52] Joe Duffy: 将物理基础设施空间完整投影至代码空间
[16:59] Joe Duffy: 只要哪里有可用的 GPU，业务就必须立刻接管那里的算力
[18:57] Joe Duffy: 从头到尾全是代码（Code all the way down）。
Andrej Karpathy: assembling IKEA furniture
Source quotes
[1:27] Andrej Karpathy: vibe coding
[1:27] Andrej Karpathy: assembling IKEA furniture
[3:09] Joe Duffy: vibe engineering
[7:07] hallucination is the antithesis to full autonomy
[18:51] code all the way down
Original transcript
[0:04] Engineers in 2026 are writing more code
[0:07] than ever before.
[0:09] It's incredible. Thanks to large
[0:10] language models and the continued
[0:12] improvement in performance, we've seen
[0:14] anywhere between 2 to 5x to 10x
[0:16] improvement in shipping app code
[0:18] velocity
[0:20] and probably on a path to 100x with
[0:22] teams of agents that are working
[0:23] autonomously around the clock to write
[0:25] application code. But unfortunately, the
[0:26] infrastructure is not keeping pace.
[0:29] And at the same time, engineers
[0:30] understand that code that they're
[0:31] writing less than ever before.
[0:34] And that may sound like a bad thing, but
[0:35] it's actually a good thing. We're
[0:36] relinquishing more control to the agents
[0:39] as their capabilities get better.
[0:41] We as humans are having to toil away
[0:43] less and we're able to depend on the
[0:45] agents to write really good, correct,
[0:48] quality code and large amounts of it. I
[0:50] mean, engineers now can ship the
[0:52] equivalent of multiple compilers per
[0:53] month.
[0:55] But because we understand it less
[0:56] before, because infrastructure is not
[0:58] keeping up, it's causing new bottlenecks
[1:01] to emerge.
[1:02] And certain things don't go away just
[1:04] because we're agentically coding. You
[1:05] know, infrastructure certainly doesn't
[1:07] go away, the need to be efficient and
[1:08] scalable, the need to have cost controls
[1:11] and security and compliance.
[1:13] These things don't just go away because
[1:15] we're using AI to write the code.
[1:17] They're as important as ever before. In
[1:19] fact, we're seeing new security and
[1:20] attack vectors as the models themselves
[1:22] get more capable.
[1:23] And so, this is a real problem for us.
[1:27] Interestingly, Andrej Karpathy wrote
[1:29] this fascinating blog post of building a
[1:31] menu application where he bycoded it and
[1:34] it was wonderful, life was great, and
[1:35] that then he got to the point where he
[1:37] wanted to deploy it.
[1:38] And I like the way he put it, he said
[1:40] building a modern app is a bit like
[1:42] assembling IKEA furniture. You've got
[1:44] all those building blocks, you get the
[1:45] torque wrenches, and you know, it's sort
[1:47] of a DIY to the end user to figure it
[1:49] out. And when it comes to configuring
[1:51] cloud services and API keys and dev
[1:55] versus prod and secrets and copy and
[1:57] pasting things all over the place. This
[1:59] is just an area that agents are not
[2:02] naturally good at.
[2:03] And we'll talk about why that is, but
[2:05] this is a problem.
[2:07] The new bottleneck is emerging where AI
[2:10] writes the code,
[2:11] the throughput of writing that code is
[2:13] growing faster than ever before
[2:16] to the point where the code is no longer
[2:17] the bottleneck.
[2:19] Having good ideas, having good taste,
[2:21] those are bottlenecks.
[2:23] But increasingly assembling that
[2:24] furniture, that IKEA furniture, getting
[2:26] that code running where it needs to run
[2:29] has become the new bottleneck.
[2:31] That includes today a lot of manual
[2:32] steps, you know, cloud consoles, API
[2:35] keys, copy and pasting YAML.
[2:37] The bottleneck is basically everything
[2:39] but the code now.
[2:42] And we've been working in this area, you
[2:44] know, I founded a company
[2:46] almost 10 years ago to develop
[2:49] infrastructure as code that is ergonomic
[2:51] for humans.
[2:53] We had gone through many eras of how to
[2:55] manage infrastructure.
[2:56] I mean, back in the day it was manual
[2:58] with cloud consoles, you point and
[2:59] click, you run manual CLI commands,
[3:01] you've got runbooks.
[3:03] Everything was imperative, every step
[3:04] was done by hand, it was not repeatable,
[3:07] it was error-prone.
[3:09] And then we moved into this world of
[3:11] config, and this is where infrastructure
[3:12] as code first came onto the scene with
[3:15] things like,
[3:16] you know, Ansible, Terraform, Salt
[3:19] Stack, eventually, you know, Kubernetes
[3:21] came out that had a YAML-based dialect
[3:24] for how you declare the infrastructure.
[3:27] But it was limited.
[3:29] It was more text than code. Even though
[3:32] we called it infrastructure as code, it
[3:33] was sort of infrastructure as text.
[3:36] And now, the thing that we at Pulumi
[3:38] were really excited about, and there are
[3:40] a number of other folks out there that
[3:42] are also excited about this, is the idea
[3:43] of using code to express the
[3:45] infrastructure.
[3:47] Now, the magic is still having a
[3:49] declarative infrastructure as code
[3:50] system, but then having the full
[3:52] expressiveness as code.
[3:54] This was originally because we wanted
[3:56] something ergonomic for humans,
[3:58] but it turns out
[4:00] sort of happy accidents, what's good for
[4:02] humans is also good for agents. And so,
[4:04] we'll talk about why this could actually
[4:06] be one of the biggest unlocks for how we
[4:08] get to a world of fully agentic
[4:11] infrastructure.
[4:14] So, I think of this as we're moving
[4:15] beyond just vibe coding to vibe
[4:17] engineering.
[4:18] Writing the code is only one small part
[4:20] of the puzzle.
[4:22] We're actually engineering entire
[4:23] systems, and engineering includes the
[4:26] coding, the testing, but also the
[4:27] deployment and the management of these
[4:29] systems in production.
[4:32] And so, the the bottleneck that we're
[4:33] now facing in 2026 is not really the
[4:36] coding bottleneck anymore. It's the
[4:38] everything else bottleneck.
[4:42] But let's
[4:43] analyze how we got here.
[4:45] Well, the scaling laws are holding, so
[4:47] the models are just getting so good, you
[4:49] know, every model out there is just so
[4:51] much better from Meta's new Spark 2 and
[4:54] Anthropic's Claude with Opus and Opus
[4:57] 4.7 recently coming out, and of course
[4:59] GPT-5.5, and then all the great
[5:01] open-source models, whether it's Quinn
[5:03] or Kimmy, and so on. But those scaling
[5:05] laws are also transferring into scaling
[5:08] code. And they transfer exceptionally
[5:11] well for a bunch of reasons. One,
[5:13] there's a lot of code on the internet.
[5:15] And these models have been able to train
[5:17] on that code.
[5:19] And
[5:20] unlike many other problem domains,
[5:22] developers
[5:23] self-document what they're doing and why
[5:26] with, you know, markdown files, but
[5:28] comments in the code. This is not true
[5:30] of many other domains. For example,
[5:33] medical industry, you know, doctors
[5:35] aren't
[5:36] proactively documenting every little
[5:39] conclusion they make and operation they
[5:41] perform and then publishing that on the
[5:43] internet where the models can learn from
[5:45] it.
[5:46] Of course, there are proprietary data
[5:48] sets that we can use to train models on.
[5:52] But the domain of coding, it's all on
[5:53] the internet. And the models have
[5:56] therefore become
[5:57] natural coders as a result.
[6:00] And we call that in-distribution. The
[6:01] code is in the distribution, in the
[6:03] training set for the models.
[6:05] And we see that I can't believe this,
[6:07] you know, putting this slide together,
[6:08] that less than two years ago, SWE-bench,
[6:11] the software engineering benchmark that
[6:12] is pretty much the gold standard for how
[6:14] agents are doing on coding, was only 33%
[6:18] out of 100.
[6:20] And in less than two years, in just 21
[6:22] months, it's increased to 86% with the
[6:24] latest frontier models.
[6:26] Which is a 75% reduction in errors. You
[6:30] can think of it kind of inverted how
[6:31] many errors is it making. That just
[6:34] means that we can lean more and more on
[6:36] the agents to do more of the coding, and
[6:38] to do it increasingly
[6:40] autonomously.
[6:41] And
[6:43] Anthropic's mythos model
[6:45] has already showing 94% on that
[6:47] benchmark. And so there's reasonably by
[6:48] end of 2026, basically most of the
[6:50] frontier models will be at at least 95%
[6:53] on SWE-bench, which means another 64%
[6:56] reduction in errors.
[6:57] And our ability to just offload more of
[7:00] the hard coding problems to those
[7:02] agents.
[7:04] Well, okay, so that's great. The models
[7:06] are getting better.
[7:07] Why is infrastructure so far behind?
[7:10] Well, it turns out
[7:11] coding benefited because it was highly
[7:13] in-distribution.
[7:14] But all of the techniques we've been
[7:15] taking for infrastructure are not.
[7:18] They're out of distribution. They're
[7:19] outside of the models training set.
[7:22] And because of that,
[7:23] you know, the models just don't
[7:24] naturally know how to do the
[7:26] infrastructure things that we're asking
[7:27] it to do. It doesn't naturally say, "Oh,
[7:30] you know, I know how to do that, so I'm
[7:31] going to, you know, go accomplish that
[7:33] task for you."
[7:35] But sort of the premise of what I'm
[7:37] going to talk about here is that if we
[7:38] fix this, if we can turn infrastructure
[7:40] problems into coding problems,
[7:43] the will naturally know how to solve
[7:44] them,
[7:45] and that's the path to fully agentic
[7:47] infrastructure.
[7:49] Why does the gap exist? Well, I kind of
[7:51] alluded to it. There's in distribution
[7:53] and out of distribution. You look at
[7:55] billions and billions of lines of code
[7:56] on GitHub, you know, TypeScript and
[7:58] Python and Go and so on and so forth,
[8:00] but also in Stack Overflow and other
[8:02] places, but there's vanishingly little
[8:05] training signal for infrastructure
[8:07] practices like pointing and clicking in
[8:09] the console, copy and pasting in API
[8:12] keys from here to there, manual
[8:13] provisioning steps, YAML glue that is
[8:16] copy pasta config, you know, there's a
[8:18] lot of things that are just not
[8:20] very in distribution and and and very
[8:24] scattered in terms of, you know, there's
[8:26] not a common approach that the model can
[8:29] learn from and understand, "Hey, here's
[8:30] this is the de facto way of of doing
[8:32] infrastructure task X, Y, and Z."
[8:37] And this training signal is wildly
[8:38] asymmetric. You know, we're talking many
[8:40] orders of magnitude difference between
[8:42] hundreds of billions of lines of general
[8:44] purpose languages that the models have
[8:45] been trained on. And by the way, it's
[8:47] not just the training, it's also the
[8:49] fine-tuning and reinforcement learning
[8:51] with AI and human feedback and the fact
[8:53] that code can be verified as correct or
[8:56] incorrect, that can be used as a reward
[8:57] signal in RL pipelines. You know, this
[9:00] is
[9:01] really why coding is so much better
[9:03] than,
[9:04] you know, running ad hoc arbitrary
[9:06] commands. It's not just that it's
[9:09] not in distribution, it's not in
[9:11] distribution, and it's hard to verify,
[9:13] and it's
[9:14] highly diffuse.
[9:16] And that's a big problem. And
[9:19] you can put things in context. If things
[9:20] are not in distribution, you can always
[9:22] put them in context, and the LLM will be
[9:24] able to
[9:26] fine-tune its attention mechanism based
[9:28] on that.
[9:29] But, you know, through things like
[9:32] skills and tools and MCP servers or
[9:34] putting it on the internet in a markdown
[9:35] file where the agent can find it.
[9:38] But if it's neither in distribution nor
[9:40] in context, the models are either in
[9:42] just going to flat out fail or they will
[9:44] hallucinate and they will certainly do
[9:45] the wrong thing.
[9:46] And hallucination is the antithesis to
[9:49] full autonomy.
[9:52] So here's the reframe, the challenge
[9:54] that I want to throw out, you know, for
[9:55] everybody to consider, which is instead
[9:57] of trying to teach the model the spoken
[9:59] infrastructure practices, which is maybe
[10:01] the natural instinct, what if we were
[10:03] instead to express infrastructure
[10:05] problems
[10:06] as coding problems and let the agent
[10:09] solve the coding problem in a language
[10:10] that is already fluent in.
[10:13] And that brings me to
[10:15] our unique kind of
[10:17] point of view on infrastructure as code,
[10:18] which is
[10:19] let's not do manual things, let's not
[10:20] invent the domain-specific languages
[10:22] that are not in distribution of the
[10:23] models. Let's just use code, which the
[10:25] models already know, humans already
[10:27] know. It's ergonomic for us, it's
[10:29] ergonomic for them.
[10:31] But let's retain all the best things
[10:33] about infrastructure as code where it's
[10:34] still declarative, we know what's going
[10:36] to happen before we do it,
[10:38] and it's fully auditable and
[10:39] controllable because that's the other
[10:41] thing with
[10:42] autonomy, with agents, we need
[10:43] guardrails.
[10:45] We need to make sure that the agents, by
[10:47] construction,
[10:48] know which guardrails they're operating
[10:50] within and don't go outside of them. And
[10:52] that's one thing that infrastructure as
[10:53] code gives us, which is a very important
[10:56] guardrail.
[10:58] So here's what it might look like.
[11:00] This code here on the left-hand side is
[11:02] defining a training cluster. This is
[11:04] going to be basically a reinforcement
[11:06] learning fleet that uses Blackwell GPUs
[11:09] running on CoreWeave as a cloud. And we
[11:12] can see here it's just Python code, just
[11:14] like we know and love, you know, Python
[11:15] code for our ML workloads, our
[11:18] you know, front-end applications, we can
[11:20] now use it for infrastructure code.
[11:22] And within this training cluster, you
[11:23] can see it's a class, so it's it's
[11:24] encapsulating some common usage pattern,
[11:27] which in this case is a CoreWeave
[11:28] Kubernetes cluster, and then spinning up
[11:31] an NVIDIA AI cluster runtime A stack
[11:34] which encapsulates itself a bunch of
[11:36] complex things like how to configure
[11:38] Nvidia operator a coop flow for GPU
[11:41] scheduling.
[11:42] But then the really cool thing about
[11:44] this is not just defining that reusable
[11:46] component. But then actually being able
[11:49] to consume it. So on the right hand side
[11:51] you can see here we're actually spinning
[11:52] up an RL stack that has one learner with
[11:55] a really expensive
[11:57] GPU cluster and then eight
[11:58] [clears throat] roll out workers. And
[12:00] you see I'm specifying the number of
[12:01] nodes, the GPU type that I want and I
[12:03] can actually use a for loop because it's
[12:05] just a language and you know in just a
[12:08] dozen lines of code I basically spun up
[12:10] a highly dynamic reinforcement learning
[12:13] fleet using best in class cloud and GPU
[12:17] hardware. And that's just the tip of the
[12:20] iceberg of what I can do once I start
[12:22] expressing this in code.
[12:26] Now I mentioned the guardrails, right?
[12:28] It's one thing to be able to just write
[12:29] a bunch of code and spin things up.
[12:32] But it's not being done imperatively.
[12:33] That's part of one of the key parts of
[12:35] infrastructure as code that's really
[12:36] important is that I can actually say
[12:40] hypothetically if I were to deploy this
[12:41] code what would happen. And in this case
[12:43] I can see the get diff cuz it's just
[12:45] code so I can see hey I changed the
[12:46] nodes is a hypothetical change you know
[12:48] let's say we're scaling up our RL stack
[12:51] in prep for releasing the next model. So
[12:54] we're going to increase the nodes in the
[12:55] cluster from four to eight and then
[12:57] we're going to increase the number of
[12:58] roll out nodes from eight to 16 and I
[13:01] can see that very plainly in the code,
[13:02] right? It looks like a normal get diff
[13:04] cuz it is just code. But the key there
[13:06] is
[13:07] sometimes what I deploy isn't
[13:09] necessarily immediately obvious just
[13:12] from the coding changes.
[13:14] Especially with the reusable component
[13:15] that might be composed by many things
[13:17] and abstracted [clears throat] and
[13:18] encapsulated it's not always clear what
[13:20] one change is going to do to the entire
[13:21] deployment and so infrastructure as code
[13:24] tools give us a way to plan and preview
[13:26] those changes. So here we can see very
[13:29] clearly, okay, we're changing changing
[13:31] learner notes from four to eight.
[13:33] And we're adding eight more rollout
[13:35] clusters. And so we can say, "Hey, yep,
[13:38] that's exactly what we want."
[13:40] But the important thing here is this is
[13:41] not just great for humans, it's also
[13:44] essential for agents. You know, I
[13:46] wouldn't write code without Git, without
[13:49] having a diff.
[13:50] And there's a reason that Cloud Code,
[13:51] you know, shows me the diff of the code
[13:53] and allows me to say yay or nay and
[13:55] understand what it's doing. And this
[13:57] effectively gives us the same thing, but
[13:59] for infrastructure.
[14:01] And so the equivalent here is if I, you
[14:04] know, hopped into Cloud Code and said,
[14:05] "Hey, scale up my RL environment because
[14:08] we're about to release a new model." And
[14:09] it's going to show me the coding changes
[14:10] as it updates the train.py file.
[14:13] It's also going to show us that preview
[14:15] again and then allow us to interactively
[14:17] deploy things and monitor. And that
[14:19] allows the agent to say, "Yep, the
[14:22] deployment I'm doing actually matches
[14:24] the intent that I expected from the
[14:26] coding changes that I made." Again, it's
[14:29] Imagine an alternative where it's just
[14:31] calling, you know, Cloud CLIs or poking
[14:33] infrastructure directly. There's no
[14:36] There's no diff. There's no notion of
[14:37] what it's going to do before it does it.
[14:39] There's no Nothing I can review. There's
[14:41] Maybe I can review the parameters it's
[14:42] going to pass to the CLI, but it's It's
[14:44] definitely not
[14:46] the same as actually just writing code
[14:48] and making it a coding problem.
[14:52] In fact, one way I like to think of it
[14:53] is
[14:54] what this approach does is basically
[14:56] takes infrastructure space and projects
[14:59] it into code space.
[15:00] And by putting something in code space,
[15:02] it makes it something that an agent can
[15:04] operate on.
[15:06] Cuz agents are really good at coding, as
[15:07] we've established.
[15:09] But then the infrastructure as code
[15:10] engine can lower those changes in code
[15:13] space back down to infrastructure space
[15:15] and accomplish whatever task it was that
[15:18] we were trying to perform in
[15:20] infrastructure land.
[15:22] And what that means is every
[15:23] infrastructure concept is basically
[15:25] realized as a coding primitive. Even
[15:27] some things that aren't
[15:29] explicitly infrastructure concepts like,
[15:32] you know, manually copy and pasting
[15:33] things instead of having
[15:35] actual abstraction.
[15:37] So, for example, resources as we saw
[15:39] just become objects.
[15:41] Untyped bags of config become typed
[15:43] arguments and variables
[15:45] where I get red squiggles if I make a
[15:47] mistake or the agent can run type
[15:49] checkers, you know, to make sure that it
[15:51] got it right. Copy and paste and lack of
[15:53] abstraction becomes real abstraction
[15:55] with classes and functions. The idea of
[15:57] sharing or reuse, now I have modules and
[15:59] packages. So, I can stick something in a
[16:01] pip package, you know, Python or an npm
[16:03] package in TypeScript. Dependencies and
[16:06] versioning become real and first class
[16:08] with package managers where I can audit
[16:10] who's on an old version and I can roll
[16:12] out new things by just bumping version
[16:13] numbers and getting previews of the
[16:15] change just like with software
[16:17] engineering.
[16:18] And ad hoc verification goes from being
[16:20] ad hoc
[16:21] to being structured with real tests and
[16:23] static analysis and linters and all the
[16:26] great things we know about, you know,
[16:27] software quality now apply to
[16:29] infrastructure as well.
[16:30] And this also helps agentic
[16:32] infrastructure because
[16:34] agents like to write tests. I don't know
[16:35] about you, but when I'm doing fully
[16:38] autonomous coding
[16:39] I often start by writing a test. I say,
[16:41] you know, write this test to prove that
[16:42] this problem exists, fix it, and prove
[16:45] that the test passes, you know, that
[16:46] that you to prove that you fixed it.
[16:48] Now, you can apply that same sort of
[16:50] test-oriented approach to infrastructure
[16:53] as well. So, very powerful
[16:55] reflecting infrastructure into the
[16:57] coding domain.
[16:59] The other great thing about code is that
[17:01] it scales with complexity.
[17:03] In fact, the harder the workload the
[17:05] more code helps. You know, you rewind
[17:08] the clock to, you know, I don't know,
[17:09] 15, 20 years ago, the era of two virtual
[17:12] machines and a database, very simple
[17:13] two-tier applications. You know, you had
[17:15] virtual machines, they didn't change
[17:17] very often and it was static, it was
[17:18] homogeneous. Yeah, maybe in that era
[17:20] having very simple DSLs or config files
[17:24] was fine. Things didn't change that
[17:26] much. We didn't need to handle the level
[17:28] of complexity that we see these days.
[17:30] But over the years as we modernized with
[17:32] serverless and containers and new
[17:34] architectures, we're now composing many
[17:37] services and many environments together.
[17:39] And in that world code really helps.
[17:41] There's a lot of interconnectivity
[17:43] between these services.
[17:45] The configurations are not simple. We've
[17:47] gone from two virtual machines in the
[17:48] database to having dozens of resources
[17:50] for a very basic architecture.
[17:53] And then think of distributed systems.
[17:55] When I think of the cloud, the thing
[17:56] that got me really excited about Pulumi
[17:58] in the first place was I worked on
[18:00] distributed systems and parallel
[18:01] computing and everything during the
[18:03] 2000s during the multi-core era and
[18:06] the cloud is really the era of
[18:08] distributed computing is here. Infinite
[18:09] compute, infinite data is at our
[18:11] fingertips.
[18:12] It's highly dynamic, highly
[18:14] heterogeneous and if we could only
[18:17] program it, then we'd be able to
[18:19] maximally kind of utilize it and that's
[18:20] where code really wins.
[18:22] And of course, where we are today is the
[18:25] AI native era where that's just getting
[18:27] to has been taken to an entirely new
[18:29] level.
[18:30] We're having enormous scale,
[18:32] truly infinite compute or we're trying
[18:34] to get there with you know, 2 gigawatts
[18:36] and 5 gigawatt data centers
[18:38] and very exotic and cross-cloud GPU
[18:40] architectures where oftentimes workloads
[18:42] are very dynamic. I mean, wherever we
[18:44] can get a GPU, we'll take a GPU. And in
[18:46] this world, code is an absolute must.
[18:51] One of the best things about my job is I
[18:52] work with some of the most amazing
[18:54] companies on the planet building
[18:57] crazy cool software with insane scales
[18:59] of infrastructure. And here are some
[19:01] examples that we've seen and the thing I
[19:03] like about this is it's entire spectrum
[19:05] of you know, size of company and size of
[19:07] team, you know, we worked with a top
[19:09] three frontier lab to scale up their
[19:12] training and inference infrastructure by
[19:14] nearly 10x in the course of a year.
[19:16] There's no way that would have been
[19:17] possible with, you know, sort of legacy
[19:19] config techniques. And code was really
[19:20] essential in doing that. Wiz, obviously
[19:23] an iconic company, is able to manage
[19:25] over a million resources and sort of
[19:27] mind-blowingly do over 100,000
[19:29] deployments per day, which is just kind
[19:31] of crazy.
[19:32] I can't believe that, but the reason
[19:33] that was possible was
[19:35] by using code, you can now embed that
[19:37] into other pieces of software that can
[19:38] then drive deployments. So, it's no
[19:40] longer humans doing the deployments.
[19:42] That's obviously a precursor to, you
[19:44] know, just agents doing those
[19:45] deployments.
[19:46] Superbase has really ridden the AI
[19:48] tsunami and is able to now stand up a
[19:50] new region in less than a week. And then
[19:53] this is an amazing story. Composable AI,
[19:55] relatively new startup. They're 100%
[19:58] agentically managed infrastructure.
[20:00] And so they, obviously human in the
[20:02] loop, you know, they're they're doing
[20:04] things the right way, but they're able
[20:05] to just unleash agents on all their
[20:07] infrastructure
[20:08] problems. And by doing that, they've
[20:11] been able to really get a lot more done
[20:13] with a pretty lean, tight team.
[20:16] And despite being at various points
[20:18] along the spectrum in terms of size and
[20:19] complexity, the one commonality across
[20:22] all of them is that it's code all the
[20:24] way down.
[20:26] And that's sort of what we're seeing.
[20:28] That's sort of precursor today already,
[20:31] over 20% of infrastructure deployments
[20:34] that we're seeing our customers do are
[20:35] agentic. And just as Dario sort of
[20:38] predicted, rightfully so, that software
[20:40] coding was going to move to be 100%
[20:43] agentic, we actually think that
[20:45] infrastructure will follow that. And so
[20:46] I think we're on a path to 100%
[20:49] agentically managed infrastructure.
[20:51] And really the foundation for that is
[20:55] by turning it into a coding problem.
[20:58] Now, the road to full autonomy is not
[21:00] easy, right? We can't just let agents
[21:02] loose in our cloud accounts. There's a
[21:04] lot of considerations to make.
[21:06] But we're already seeing some autonomous
[21:08] workflows. For example, at Pulumi, we
[21:11] allow our agents to clean up cloud waste
[21:13] in our dev accounts.
[21:14] And I think as the models improve,
[21:16] agents get more capable, the risk-reward
[21:18] shifts. So, take that example I just
[21:21] gave.
[21:22] Well, if the agent deletes something it
[21:24] shouldn't have in our dev account, is
[21:26] that going to be annoying? Maybe.
[21:28] But, the potential reward is much
[21:30] higher. It's going to save us thousands
[21:31] of dollars per day potentially by by
[21:33] doing that. So, the risk-reward makes
[21:35] sense there.
[21:36] Proactively going and tagging resources
[21:38] that are untagged or fixing compliance
[21:40] issues that might have lain dormant with
[21:42] without having agentic infrastructure,
[21:44] the risk-reward today probably is right.
[21:48] But, there's certainly things that are
[21:49] human-assisted like deploying to prod
[21:51] or, you know, an entirely new
[21:53] infrastructure pro- project.
[21:55] There are things that are supervised
[21:56] like, you know, maybe whether the agent
[21:59] auto scales my environment or not. Maybe
[22:01] I want a human to look at that and
[22:02] approve of it before it goes and does
[22:04] that.
[22:05] But, I really do think the future is
[22:08] self-managing teams of agents managing
[22:10] the infrastructure.
[22:11] And that allows us humans to focus more
[22:13] on value-add activities.
[22:17] And so, we're really excited about the
[22:19] future of agentic infrastructure.
[22:21] Really honored to play in the role that
[22:24] we've been playing and working with some
[22:25] of the most innovative companies in the
[22:26] industry. I hope we inspired you to to
[22:29] think about infrastructure more as a
[22:31] coding problem.
[22:32] And hopefully leave you as excited as we
[22:34] are about the the possible autonomous
[22:37] infrastructure
[22:38] that we have in our future. So, thank
[22:40] you.
