# The Infinite Software Crisis

Jake Nations

AI Engineer Code 2025

[Talk page](https://ai.engineer/talks/eIoohUmYpGI-infinite-software-crisis) · [Video](https://www.youtube.com/watch?v=eIoohUmYpGI)

## The Infinite Software Crisis: Keeping Human Understanding Ahead of AI-Generated Code

Jake Nations explains why faster code generation can compound accidental complexity, and how research, implementation planning, and hard-earned system knowledge help engineers remain accountable for what they ship.

![Selected presentation frame from The Infinite Software Crisis – Jake Nations, Netflix at 700 seconds](https://ai.engineer/api/talk-essay-media/284e834f28e98bbe9c9611834e783e61b83fc9f209654226736a8e57bafb74f5)

The Infinite Software Crisis: Keeping Human Understanding Ahead of AI-Generated Code

### The bottleneck has moved from writing code to understanding it

[0:21](https://www.youtube.com/watch?v=eIoohUmYpGI&t=21s)

Jake Nations begins with an uncomfortable admission: he has generated, tested, deployed, and shipped code he could not fully explain. His experience helping drive AI-tool adoption at Netflix makes the benefits equally clear: work that once took days can take hours, and long-postponed refactors become feasible. But production systems fail in unexpected ways, and passing tests do not guarantee that engineers will understand the code when they need to debug it. [0:21](https://www.youtube.com/watch?v=eIoohUmYpGI&t=21s) [1:19](https://www.youtube.com/watch?v=eIoohUmYpGI&t=79s)

He places this tension within a recurring history of software crises. As computing capability and demand expanded, successive generations adopted new languages, personal computers, object-oriented programming, Agile, cloud infrastructure, mobile development, and DevOps. Each wave increased what developers could produce, but none eliminated the difficulty of managing growing systems. AI continues that pattern while dramatically increasing the scale and speed of code generation. [1:19](https://www.youtube.com/watch?v=eIoohUmYpGI&t=79s) [2:15](https://www.youtube.com/watch?v=eIoohUmYpGI&t=135s) [3:13](https://www.youtube.com/watch?v=eIoohUmYpGI&t=193s)

Fred Brooks' **No Silver Bullet** provides the central distinction: the hardest part of software development is not syntax, typing, or boilerplate, but understanding the problem and designing an appropriate solution. Tools can accelerate the mechanical work without removing that underlying challenge. When generation becomes nearly immediate, the limiting factor becomes whether human comprehension can keep pace with the volume of software being created. [3:13](https://www.youtube.com/watch?v=eIoohUmYpGI&t=193s) [16:28](https://www.youtube.com/watch?v=eIoohUmYpGI&t=988s)

![Selected presentation frame from The Infinite Software Crisis – Jake Nations, Netflix at 115 seconds](https://ai.engineer/api/talk-essay-media/e0641677e351c385ccb9b7fa37b17737a21b681fdb8a9eecc3fb4110b0f876ca)

The bottleneck has moved from writing code to understanding it

- AI can compress days of work into hours while producing deployed code its authors cannot fully explain.
- Passing tests do not establish the understanding needed to debug unexpected production failures.
- Faster code generation accelerates mechanical work without resolving problem understanding or solution design.
- When generation outpaces comprehension, system understanding becomes the practical bottleneck.

### Easy code is not necessarily simple code

[4:14](https://www.youtube.com/watch?v=eIoohUmYpGI&t=254s)

Nations uses Rich Hickey's distinction between **simple** and **easy** to explain why capable engineers still create systems they struggle to understand. Simple describes structure: components remain disentangled and each part has a clear responsibility. Easy describes accessibility: a package, copied solution, framework, or generated implementation is immediately available with little effort. Making something easy does not make its underlying structure coherent. [4:14](https://www.youtube.com/watch?v=eIoohUmYpGI&t=254s)

Before AI, teams could often absorb the tradeoff between immediate convenience and future complexity because code accumulated slowly enough to revisit and refactor. Nations argues that AI disrupts this balance by making implementation so frictionless that architectural deliberation becomes easier to skip. The immediate reward is speed; the deferred cost is a system whose behavior and dependencies become progressively harder to reason about. [5:12](https://www.youtube.com/watch?v=eIoohUmYpGI&t=312s)

His illustrative authentication scenario shows the mechanism. A straightforward auth.js implementation expands to OAuth.js, broken sessions, conflicting approaches, patched tests, and abandoned code as conversational instructions accumulate. Each request can resolve its immediate symptom while overriding earlier architectural decisions. By the twentieth interaction, the developer may be managing a tangled history of constraints rather than deliberately shaping a comprehensible system. [5:12](https://www.youtube.com/watch?v=eIoohUmYpGI&t=312s) [6:07](https://www.youtube.com/watch?v=eIoohUmYpGI&t=367s)

The deeper problem is that a coding agent can treat every existing implementation as a pattern worth preserving, including old workarounds and architectural mistakes. An authentication check and an awkward legacy gRPC pattern can both appear as equally legitimate precedent. Without human judgment about which structures should survive, generation reproduces existing complexity while adding new layers around it. [6:55](https://www.youtube.com/watch?v=eIoohUmYpGI&t=415s) [7:53](https://www.youtube.com/watch?v=eIoohUmYpGI&t=473s)

![Selected presentation frame from The Infinite Software Crisis – Jake Nations, Netflix at 365 seconds](https://ai.engineer/api/talk-essay-media/e98519b47d496802b1c5d82c7b98e68071002d35d257fc33a07d54e9d5a03fde)

Easy code is not necessarily simple code

- Simple means disentangled structure; easy means immediately accessible implementation.
- Frictionless generation favors immediate speed while accumulating architectural complexity.
- Repeated authentication changes can produce broken sessions, conflicting approaches, patched tests, and dead code.
- Agents preserve useful patterns and technical debt alike unless engineers distinguish between them.

### Separate essential requirements from accidental complexity

[6:55](https://www.youtube.com/watch?v=eIoohUmYpGI&t=415s)

Nations distinguishes **essential complexity**, the difficulty inherent in the problem the software exists to solve, from **accidental complexity**, the accumulated machinery introduced while implementing it. Payments and order fulfillment exemplify essential requirements. Workarounds, defensive code, aging frameworks, and once-useful abstractions can become accidental complexity when they persist beyond their original purpose. In established systems, the two become intertwined, and separating them requires context, history, and experience. [6:55](https://www.youtube.com/watch?v=eIoohUmYpGI&t=415s) [7:53](https://www.youtube.com/watch?v=eIoohUmYpGI&t=473s)

A Netflix authorization migration illustrates why this distinction matters. An abstraction layer had been introduced between older authorization code and a newer centralized auth system because rebuilding the entire application was impractical. Although replacing the intermediary layer seemed like a natural AI-assisted refactor, the older authorization model was deeply embedded in business logic, data models, and permission checks spread across hundreds of files. [7:53](https://www.youtube.com/watch?v=eIoohUmYpGI&t=473s) [8:52](https://www.youtube.com/watch?v=eIoohUmYpGI&t=532s)

The agent could make progress in a few files before encountering dependencies it could not cleanly untangle, or it could reproduce assumptions from the old system using the new one. The problem was not merely insufficient code visibility: the boundary between authorization behavior and business behavior was itself obscured. Nations argues that engineers must identify those architectural **seams** and distinguish actual requirements from historical implementation choices before asking AI to execute the migration. [8:52](https://www.youtube.com/watch?v=eIoohUmYpGI&t=532s) [9:50](https://www.youtube.com/watch?v=eIoohUmYpGI&t=590s)

![Selected presentation frame from The Infinite Software Crisis – Jake Nations, Netflix at 546 seconds](https://ai.engineer/api/talk-essay-media/3a975e0a91cebb6c54c0f47fa411bc2ed391e35f6f2379599d5a3748c85f0359)

Separate essential requirements from accidental complexity

- Essential complexity belongs to the underlying problem; accidental complexity comes from accumulated implementation machinery.
- A temporary authorization shim connected legacy authorization code to a newer centralized system.
- Permission checks, role assumptions, and scattered authorization calls obscured boundaries across hundreds of files.
- Identify architectural seams and historical assumptions before asking an agent to migrate tightly coupled code.

### Compress system understanding into research, planning, and implementation

[9:50](https://www.youtube.com/watch?v=eIoohUmYpGI&t=590s)

The scale of Nations' codebase forced a more selective approach. He describes approximately a million lines of Java and a main service comprising roughly five million tokens, beyond the context windows available to him. Supplying large portions of the code directly did not reveal a clean architectural picture; instead, the generated output became lost in the same complexity. He therefore selected relevant design documents, architecture diagrams, interfaces, component interactions, and behavioral requirements, reducing the problem into an approximately 2,000-word specification and a precise execution sequence. [9:50](https://www.youtube.com/watch?v=eIoohUmYpGI&t=590s) [10:44](https://www.youtube.com/watch?v=eIoohUmYpGI&t=644s)

The first phase is **research**. Relevant documentation, architectural material, Slack threads, and codebase analysis help the agent map components, dependencies, and the likely impact of a proposed change. This phase is iterative: the engineer probes areas such as caching and failure handling, supplies missing context, and corrects mistaken analysis. Its deliverable is a research document describing what exists, how the pieces connect, and what the change will affect; critically, a human validates that document against the actual system before proceeding. [10:44](https://www.youtube.com/watch?v=eIoohUmYpGI&t=644s) [11:43](https://www.youtube.com/watch?v=eIoohUmYpGI&t=703s)

The second phase is **implementation planning**. Using the validated research, the engineer develops a concrete plan covering code structure, function signatures, type definitions, data flow, service boundaries, and complex business logic. This is where architectural decisions are made explicitly and unnecessary coupling can be identified early. Nations emphasizes that a sufficiently detailed plan can be reviewed quickly and followed predictably, allowing comprehension to keep pace with subsequent code generation. [11:43](https://www.youtube.com/watch?v=eIoohUmYpGI&t=703s) [12:40](https://www.youtube.com/watch?v=eIoohUmYpGI&t=760s)

The final phase is **implementation** against the approved plan. Instead of allowing a lengthy conversation to repeatedly reshape the design, the workflow produces three focused, sequentially validated artifacts: research, plan, and implementation. A background agent can handle much of the mechanical coding while the engineer works elsewhere, and review becomes a matter of checking whether the implementation conforms to the agreed design. The intended division of labor is clear: AI accelerates execution, while humans retain synthesis, judgment, and architectural responsibility. [12:40](https://www.youtube.com/watch?v=eIoohUmYpGI&t=760s) [13:32](https://www.youtube.com/watch?v=eIoohUmYpGI&t=812s)

![Selected presentation frame from The Infinite Software Crisis – Jake Nations, Netflix at 735 seconds](https://ai.engineer/api/talk-essay-media/8f39517eecda3cc5b568b6ee09e1620ec804514476499ced82579da30fd131ca)

Compress system understanding into research, planning, and implementation

- Compress relevant architecture, interfaces, and requirements into a focused specification before generating code.
- Research maps components, dependencies, and change impact; validate its conclusions against the actual system.
- Translate validated research into an implementation plan covering signatures, types, data flow, boundaries, and coupling.
- Generate against the approved plan, then review implementation for conformance rather than rediscovering its design.

Research-to-implementation workflow
Validate system understanding before defining architecture and generating implementation.
- Research — Map components, dependencies, and change impact.
- Human validation — Check research against the actual system.
- Implementation plan — Specify structure, types, data flow, and boundaries.
- Implementation — Generate focused code against the approved plan.
- Conformance review — Verify generated code follows the plan.
- Research → Human validation (Validate findings)
- Human validation → Implementation plan (Use validated research)
- Implementation plan → Implementation (Follow the clear plan)
- Implementation → Conformance review (Check plan conformance)

### Earn the understanding before trying to automate it

[14:29](https://www.youtube.com/watch?v=eIoohUmYpGI&t=869s)

The authorization migration also exposes an important limitation of the three-phase method: it could not begin effectively until the team performed an initial migration manually. Engineers read the existing code, traced dependencies, changed the implementation, and observed what broke. That difficult exercise uncovered hidden constraints, necessary invariants, and services affected by authorization changes—knowledge that Nations says code analysis alone had not surfaced. [14:29](https://www.youtube.com/watch?v=eIoohUmYpGI&t=869s)

The team then used the manually created pull request as a concrete example for subsequent research. Even with that reference, individual entities differed, including whether some data was encrypted, so engineers had to supply additional context and interrogate the analysis case by case. Nations is explicit that the resulting plans might work, not that they are guaranteed to work: the team remained in the process of validating, adjusting, and discovering edge cases. [14:29](https://www.youtube.com/watch?v=eIoohUmYpGI&t=869s) [15:24](https://www.youtube.com/watch?v=eIoohUmYpGI&t=924s)

This limitation reinforces the larger argument. There is no promised rescue through better prompts, larger models, or more polished specifications alone. Code that passes tests is not automatically code that will survive production or remain understandable to future maintainers. Safe automation depends on acquiring enough knowledge of the system to recognize meaningful boundaries, preserve necessary invariants, and judge whether generated changes actually solve the right problem. [15:24](https://www.youtube.com/watch?v=eIoohUmYpGI&t=924s) [16:28](https://www.youtube.com/watch?v=eIoohUmYpGI&t=988s) [17:21](https://www.youtube.com/watch?v=eIoohUmYpGI&t=1041s)

Nations also warns that repeatedly skipping the thinking required to understand generated systems can weaken engineers' ability to recognize dangerous architectural patterns. That judgment develops through experience maintaining difficult systems and confronting failures. His proposed workflow preserves reviewable artifacts that compress understanding without outsourcing it. The defining question is not whether AI will write more software, but whether the people responsible for that software will still understand the systems they operate. [16:28](https://www.youtube.com/watch?v=eIoohUmYpGI&t=988s) [17:21](https://www.youtube.com/watch?v=eIoohUmYpGI&t=1041s) [18:20](https://www.youtube.com/watch?v=eIoohUmYpGI&t=1100s)

![Selected presentation frame from The Infinite Software Crisis – Jake Nations, Netflix at 931 seconds](https://ai.engineer/api/talk-essay-media/5cbab0317d2fccfca4e1fce432d9f3e7339ce1152063b3354ca93e9b2346263f)

Earn the understanding before trying to automate it

- Manually migrate one representative case to uncover hidden constraints, required invariants, and affected services.
- Use the completed migration pull request as a concrete research example for subsequent changes.
- Account for entity-specific differences, including encryption, and keep validating plans and edge cases.
- Preserve human architectural judgment: passing tests and rapid generation do not guarantee production resilience or maintainability.

Earn understanding before automation
A manual migration establishes the concrete knowledge needed for later assisted migrations.
- Manual migration — Read code, trace dependencies, and make changes.
- Exposed constraints — Discover invariants, affected services, and breakage.
- Reference pull request — Seed research with the completed migration.
- Case-specific research — Add context for differences such as encryption.
- Validated migration plan — Generate, adjust, and check for edge cases.
- Manual migration → Exposed constraints (Reveals hidden conditions)
- Exposed constraints → Reference pull request (Captured in manual migration)
- Reference pull request → Case-specific research (Seeds subsequent research)
- Case-specific research → Validated migration plan (Enables a candidate plan)

## Key takeaways

- AI can dramatically accelerate implementation, but the core engineering challenge remains understanding the problem, designing the solution, and explaining the resulting system. [0:21](https://www.youtube.com/watch?v=eIoohUmYpGI&t=21s) [3:13](https://www.youtube.com/watch?v=eIoohUmYpGI&t=193s)
- **Easy** means readily accessible; **simple** means structurally disentangled. Frictionless generation can increase complexity even when each individual change appears successful. [4:14](https://www.youtube.com/watch?v=eIoohUmYpGI&t=254s) [5:12](https://www.youtube.com/watch?v=eIoohUmYpGI&t=312s) [6:07](https://www.youtube.com/watch?v=eIoohUmYpGI&t=367s)
- Agents may preserve both essential behavior and historical technical debt unless engineers explicitly distinguish genuine requirements from accidental complexity. [6:55](https://www.youtube.com/watch?v=eIoohUmYpGI&t=415s) [7:53](https://www.youtube.com/watch?v=eIoohUmYpGI&t=473s) [8:52](https://www.youtube.com/watch?v=eIoohUmYpGI&t=532s)
- Use three human-validated phases—**research**, **implementation planning**, and **implementation**—to compress relevant system knowledge into artifacts that can be reviewed before code is generated. [10:44](https://www.youtube.com/watch?v=eIoohUmYpGI&t=644s) [11:43](https://www.youtube.com/watch?v=eIoohUmYpGI&t=703s) [12:40](https://www.youtube.com/watch?v=eIoohUmYpGI&t=760s) [13:32](https://www.youtube.com/watch?v=eIoohUmYpGI&t=812s)
- When architectural boundaries and invariants are unclear, perform an initial migration manually and use the resulting concrete example to guide subsequent AI-assisted work. [14:29](https://www.youtube.com/watch?v=eIoohUmYpGI&t=869s) [15:24](https://www.youtube.com/watch?v=eIoohUmYpGI&t=924s)
- Treat passing tests and generated plans as insufficient proof of production readiness; continue validating edge cases, maintainability, hidden dependencies, and the team's understanding. [15:24](https://www.youtube.com/watch?v=eIoohUmYpGI&t=924s) [16:28](https://www.youtube.com/watch?v=eIoohUmYpGI&t=988s) [17:21](https://www.youtube.com/watch?v=eIoohUmYpGI&t=1041s)

## Slides

### And I bet you have too!

Jake Nations confesses that he generated, tested and deployed code he couldn't explain, and bets the audience has done the same.

[0:34](https://www.youtube.com/watch?v=eIoohUmYpGI&t=34s) [Slide displaying the phrase “and I bet you have too!”](https://assets.ai.engineer/sites/aiecode2025/sha256/1aacae2ecb4926296008c1fe6bcc7a3ef32dd6d076a51893f4ff5ed47c28aa30.webp)

and I bet you have too!

THE INFINITE SOFTWARE CRISIS
JAKE NATIONS / Staff Software Engineer
NETFLIX

AIE / CODE
PRESENTED BY
Google DeepMind

### Story in Three Parts

Jake Nations traces how developers came to ship code they don't understand, looking at repeating history, the difference between easy and simple, and the need to keep thinking for ourselves.

[0:38](https://www.youtube.com/watch?v=eIoohUmYpGI&t=38s) [Agenda: history repeats, easy is not simple, and don’t outsource thinking.](https://assets.ai.engineer/sites/aiecode2025/sha256/9f37c3d01ee972715686d6e94a85b8421f8dc58b98091e578ae67b47c7223dbb.webp)

Story in Three Parts:
1. History Repeats
2. Easy ≠ Simple
3. Don’t outsource Thinking

Interface text:
AIE / CODE
PRESENTED BY
Google DeepMind
THE INFINITE SOFTWARE CRISIS
JAKE NATIONS / Staff Software Engineer
NETFLIX

### Each Solution Enabled Bigger Problems

Nations traces a cycle from C’s larger systems to cloud and mobile: each advance enabled more software while bringing new problems.

[2:53](https://www.youtube.com/watch?v=eIoohUmYpGI&t=173s) [Timeline from C in the 1970s through personal computers, object-oriented programming, Agile, and cloud and mobile.](https://assets.ai.engineer/sites/aiecode2025/sha256/f922b832ad12871a4adf5720cecc4eaf8a985c1b3bc93f0f4d2d84b345956412.webp)

Each Solution Enabled Bigger Problems

1. 1970s
C Language
We built larger systems

2. 1980s
Personal Computers
Everyone could create software

3. 1990s
Object-Oriented Programming
Inheritance hierarchies from hell

4. 2000s
Agile
Sprints and scrum masters

5. 2010s
Cloud & Mobile
Software ate the world

Interface text:
AIE / CODE
PRESENTED BY
Google DeepMind
THE INFINITE SOFTWARE CRISIS
JAKE NATIONS / Staff Software Engineer
NETFLIX

### Simple vs Easy

Rich Hickey’s distinction separates structure from proximity: simple pieces do one thing without entanglement, while easy options are within reach, like copying code or installing a package.

[4:32](https://www.youtube.com/watch?v=eIoohUmYpGI&t=272s) [Two columns contrast simplicity and lack of entanglement with ease and proximity, citing Rich Hickey’s Simple Made Easy.](https://assets.ai.engineer/sites/aiecode2025/sha256/a1c2a5d666cf397192acb18a6d10fe868d7136ab166f1b104684e911fd9b3cd4.webp)

Simple vs Easy

Simple
One fold, one braid
Single responsibility
Lack of entanglement
Requires design, thought, untangling

Easy
Adjacent, reachable
Copy, paste, ship
Install a package
Just put it closer

Rich Hickey, 2011 - Simple Made Easy: We use these words interchangeably, but they're not the same at all. Conflating them is why we're drowning in complexity.

Interface text:
AI Engineer
Engineering the future of AI

### We can’t make something simple by wishing it so

Easy choices trade speed now for complexity later. The speaker argues AI accelerates that accumulation, upsetting the earlier balance that left time to refactor.

[4:47](https://www.youtube.com/watch?v=eIoohUmYpGI&t=287s) [Three boxes describe the easy path, speed now and complexity later, and the balance that allowed time to refactor.](https://assets.ai.engineer/sites/aiecode2025/sha256/29855011fb784be70b5feaa906557eeddc5675214a3ad2e1cc813e1e213366e4.webp)

We can't make something simple by wishing it so

Human Nature
We're wired to take the easy path

The Trade-Off
Easy means speed now, complexity later

The Balance
Complexity accumulated slowly enough to refactor

Interface text:
AI Engineer
Engineering the future of AI

### The Conversation Spiral

In a contrived authentication example, successive requests turn a clean auth.js file into multiple files, broken sessions and conflicts. By message 20, the accumulated context has become hard to manage.

[5:57](https://www.youtube.com/watch?v=eIoohUmYpGI&t=357s) [A diagram shows successive authentication requests evolving from a clean file to conflicting files and chaos.](https://assets.ai.engineer/sites/aiecode2025/sha256/de4340ea991c55454e15448b5164edaa1a7f14e7387cdce128da56ff7b4532b3.webp)

The Conversation Spiral
AI makes problem-solving easy by engaging in a continuous dialogue.

Message 1
'Add authentication' → ✓ Clean auth.js

Message 5
'Also add OAuth' → ! auth.js + oauth.js

Message 12
'Sessions broken, add SSO' → 🔥 4 files, conflicts

Message 20
'Just make it work' → 💀 Complete chaos

AI Engineer
Engineering the future of AI

### Why AI Can't Tell What Matters: Complexity

The speaker says AI treats codebase patterns alike, so technical debt can look like code to preserve. Complexity involves a system’s states, transitions, components and dependencies.

[7:02](https://www.youtube.com/watch?v=eIoohUmYpGI&t=422s) [Complexity is described in terms of system states, transitions, components and dependencies.](https://assets.ai.engineer/sites/aiecode2025/sha256/c1444345d67059dba422ccd5196759ddaa52a55670f3e1979ff1d4c6312e1aad.webp)

Why AI Can't Tell What Matters

Complexity
• The number of states and transitions in a system
• The number of components and their dependencies
• The opposite of simple

Interface text:
AI Engineer
Engineering the future of AI

### Why AI Can't Tell What Matters: Types of Complexity

Business needs like payments and fulfillment become tangled with accumulated implementation details. Separating them requires context and experience; generated output preserves patterns without making that distinction.

[7:39](https://www.youtube.com/watch?v=eIoohUmYpGI&t=459s) [The slide contrasts accumulated implementation details with essential business needs such as payments and order fulfillment.](https://assets.ai.engineer/sites/aiecode2025/sha256/6e0bdf9c9dcae2708510bfcd6d11fd02374e53bc44e92f9684a1d764ce62c526.webp)

Why AI Can't Tell What Matters

Accidental Complexity
• All the implementation details we've accumulated.
• Permission checks woven through business logic.
• Role assumptions baked into data models.

Essential Complexity
• The actual business problem you're solving.
• Users need to pay.
• Orders need fulfillment.

Interface text:
AI Engineer
Engineering the future of AI

### A Real Example

At Netflix, an AI agent trying to replace an authorization shim hit dependencies it couldn't untangle. It sometimes recreated old logic in the new system instead.

[8:28](https://www.youtube.com/watch?v=eIoohUmYpGI&t=508s) [Three panels describe legacy authorization code, the AI's difficulty refactoring it, and tangled dependencies.](https://assets.ai.engineer/sites/aiecode2025/sha256/925c9448c4109899ab6dfbd8a87984556b9d528fd76a479bf4910c045b5e1515.webp)

A Real Example

We asked AI to refactor old, tightly coupled authorization code to use our new centralized system.

The Legacy Labyrinth
Old authorization code was deeply embedded. Permission checks were woven through business logic, role assumptions baked into data models, and authentication calls scattered across hundreds of files.

AI's Frustration
The AI struggled immensely with this task, often recreating old patterns and failing to grasp the underlying system. It couldn't just "remove" the abstraction layer.

Untangleable Dependencies
AI repeatedly hit untangleable issues, highlighting the depth of accidental complexity in the legacy system.

Interface text:
AIE / CODE
PRESENTED BY
Google DeepMind
THE INFINITE SOFTWARE CRISIS
JAKE NATIONS / Staff Software Engineer
NETFLIX

### It Couldn't See the Seams

In the authorization refactor, the agent couldn't separate business logic from auth logic. It hit dependencies it couldn't untangle and sometimes recreated old logic in the new system.

[9:19](https://www.youtube.com/watch?v=eIoohUmYpGI&t=559s) [The slide says the AI could not distinguish intertwined business and authorization logic or find a clean path through it.](https://assets.ai.engineer/sites/aiecode2025/sha256/69d44656b2997bd5bee127672b12a0043eb607d95519b3de4e7d4944f1cd5129.webp)

It Couldn't See the Seams

AI couldn't identify where business logic ended and auth logic began.

Everything was so intertwined that even with perfect information, it couldn't find a clean path through.

AIE / CODE
PRESENTED BY
Google DeepMind

THE INFINITE SOFTWARE CRISIS
JAKE NATIONS / Staff Software Engineer
NETFLIX

### The 5 Million Token Problem

Nations selected design docs, diagrams and interfaces to turn a service of about five million tokens into a 2,000-word specification. He then planned precise code steps and reports cleaner, more focused output.

[9:57](https://www.youtube.com/watch?v=eIoohUmYpGI&t=597s) [A five-million-token codebase exceeds the available chat context; selected artifacts inform a markdown specification of requirements, patterns and constraints.](https://assets.ai.engineer/sites/aiecode2025/sha256/3a0d3c859fc5e05abbada389c859edfc5200f1c31614d349c671347252c5822d.webp)

The 5 Million Token Problem

The Problem
5 million token codebase. No chat window could hold that context.

The Constraint
Selected key artifacts: design docs, architecture diagrams, interfaces.

The Specification
5 million tokens became a single markdown doc.
Requirements, patterns, constraints.

AIE / CODE
PRESENTED BY
Google DeepMind

THE INFINITE SOFTWARE CRISIS
JAKE NATIONS / Staff Software Engineer
NETFLIX

### Three Steps of Context Compression

Nations puts thinking and planning ahead of code generation: research builds shared context, planning structures the implementation, and a validated specification guides the code.

[11:17](https://www.youtube.com/watch?v=eIoohUmYpGI&t=677s) [Three steps: research to build shared context, planning to create a structured implementation plan, and implementation from a validated specification.](https://assets.ai.engineer/sites/aiecode2025/sha256/5cbec16263c78035b6ca83ee4a3865bede5f87028ef46057c855f062d9bab156.webp)

Three Steps of Context Compression

1 Research
Build shared context through focused iteration.

2 Planning
Create detailed implementation plan with structure.

3 Implementation
Generate code from validated specification.

AIE / CODE
PRESENTED BY
Google DeepMind
THE INFINITE SOFTWARE CRISIS
JAKE NATIONS / Staff Software Engineer
NETFLIX

### Phase 1: Research

Nations feeds relevant context to an agent, then probes and corrects its codebase analysis. The resulting research document maps components, dependencies, and what the change will affect.

[11:26](https://www.youtube.com/watch?v=eIoohUmYpGI&t=686s) [Research inputs include architecture diagrams, documentation, Slack threads, runbooks, and design documents.](https://assets.ai.engineer/sites/aiecode2025/sha256/d9e6a518a151b7db8053d8cef8bcb3f3bf7fb2798beda561e77707bdae8cad77.webp)

Phase 1: Research

Feed everything relevant upfront:
• Architecture diagrams
• Documentation
• Slack threads
• Runbooks
• Design docs

AIE / CODE
PRESENTED BY
Google DeepMind

THE INFINITE SOFTWARE CRISIS
JAKE NATIONS / Staff Software Engineer
NETFLIX

### The Human Checkpoint

Jake Nations calls for a human to validate the research analysis against reality before planning, catching errors before they become disasters.

[12:04](https://www.youtube.com/watch?v=eIoohUmYpGI&t=724s) [A human validates the analysis against reality and catches errors early.](https://assets.ai.engineer/sites/aiecode2025/sha256/64f0dc44186b667e3c46228d9e20e4aedbeb05eb80c1f237451b8f5582e5d48a.webp)

The Human Checkpoint

The human checkpoint is critical. This is where you validate the analysis against reality. It's the highest-leverage moment in the entire process. Catch errors here, prevent disasters later.

Interface text:
AIE / CODE
PRESENTED BY
Google DeepMind
THE INFINITE SOFTWARE CRISIS
JAKE NATIONS / Staff Software Engineer
NETFLIX

### Phase 2: Planning

With validated research in hand, build an implementation plan specifying the code structure and data flow. Nations wants it detailed enough for even a junior developer to follow.

[12:17](https://www.youtube.com/watch?v=eIoohUmYpGI&t=737s) [A detailed plan specifies function signatures, types, data flow, files, functions, and component interactions.](https://assets.ai.engineer/sites/aiecode2025/sha256/4cce0cacd9c9cd0f028f2d251ef6afd6c36983f68c4656fcb1243ed8cd661543.webp)

Phase 2: Planning

Create detailed plan with actual code structure:
• Function signatures, type definitions
• Exact flow of data
• Which files to modify
• What functions to create
• How components interact

THE INFINITE SOFTWARE CRISIS
JAKE NATIONS / Staff Software Engineer
NETFLIX

### Phase 3: Implementation

With research and planning validated, a background agent can implement the specification while the engineer works elsewhere. Review checks the result against the plan instead of reconstructing decisions from a long conversation.

[13:16](https://www.youtube.com/watch?v=eIoohUmYpGI&t=796s) [Implementation follows validated research and planning, with a clear specification, focused context, a background agent, and fast review.](https://assets.ai.engineer/sites/aiecode2025/sha256/c243f3e572cabe84ced97e598be8c298876cd3b24514790476479ef2f207800a.webp)

Phase 3: Implementation
Only after validating both understanding and plan do we generate code.

Clear Specification
AI has focused context to follow

No Complexity Spiral
Three focused outputs, not 50 messages of evolution

Background Agent
Hand off implementation, work on something else

Fast Review
Verify conformance to plan, not understand what got invented

AI Engineer
Engineering the future of AI

### AI Accelerates Your Thinking

AI speeds up mechanical work while people retain synthesis, judgment, and responsibility for spotting complexity before it spreads.

[14:15](https://www.youtube.com/watch?v=eIoohUmYpGI&t=855s) [Slide saying that synthesis, judgment, and spotting complexity remain human responsibilities.](https://assets.ai.engineer/sites/aiecode2025/sha256/566e49ff8888588b296ea6886fcfe83af586f7fa665294fef4797b2621579a98.webp)

AI Accelerates Your Thinking

The thinking remains ours. Synthesis. Judgment.
Spotting complexity before it spreads.

Interface text:
AI Engineer
Engineering the future of AI

### The Authorization Refactor Revisited

A hand-built migration exposed constraints and seeded AI research. The research raised ten questions for human judgment; the resulting plan for remaining services is still being validated as edge cases emerge.

[14:36](https://www.youtube.com/watch?v=eIoohUmYpGI&t=876s) [Slide outlining manual migration, research, questions, and planning for an authorization refactor.](https://assets.ai.engineer/sites/aiecode2025/sha256/97e36a6357965e4a7bf1ae60b3f34b2183dafb0010b6dd8cb79b48e94ba26138.webp)

The Authorization Refactor Revisited

BEFORE
AFTER

01
Manual Migration
First migration completely by hand without AI. Revealed hidden constraints and invariants.

02
Seed the Research
Fed handcrafted PR into research phase. AI could see pattern of successful migration.

03
Generate Questions
Research phase produced ten specific questions requiring human judgment.

04
Plan & Execute
Generated plan for remaining services. Still validating, still discovering edge cases.

AI Engineer
Engineering the future of AI

### There Is No Silver Bullet

The three-phase approach depended on a migration done by hand: it gave the team understanding they could encode in the process. Safely changing a system still requires that depth of understanding.

[15:48](https://www.youtube.com/watch?v=eIoohUmYpGI&t=948s) [A silver bullet illustration accompanies the message that safely changing a system requires understanding it deeply.](https://assets.ai.engineer/sites/aiecode2025/sha256/4c4b97089334961250e85a3802d6e357bffd3e85f4d2f1b0a2e11a31576bf5db.webp)

THERE IS NO SILVER BULLET

Not better prompts, not better models, not even writing specs. Just the unavoidable work of understanding your system deeply enough to change it safely.

Interface text:
AI Engineer
Engineering the future of AI

### The Human Element

Nations contrasts AI generating 1,000 lines in seconds with the hours or days needed to understand them. He connects recognition of dangerous patterns to debugging experience.

[16:31](https://www.youtube.com/watch?v=eIoohUmYpGI&t=991s) [The Knowledge Gap: AI can generate code quickly, but understanding it takes much longer; a developer works at a computer.](https://assets.ai.engineer/sites/aiecode2025/sha256/ab24e1760fae7178145e28c1ca8e958f2cd88cdbee220ef31d245c717e015af1.webp)

The Human Element

The Knowledge Gap
• AI generates 1,000 lines in seconds
• Understanding takes hours or days
• Maybe never if truly tangled

“When I recognize a dangerous pattern, it's because I've debugged it at 3 AM”

AIE / CODE
PRESENTED BY
Google DeepMind

THE INFINITE SOFTWARE CRISIS
JAKE NATIONS / Staff Software Engineer
NETFLIX

### Your Competitive Advantage

Nations compares earlier software crises with infinite code generation, arguing that developers’ advantage lies in understanding what they’re building and recognizing when they’re solving the wrong problem.

[17:37](https://www.youtube.com/watch?v=eIoohUmYpGI&t=1057s) [The slide describes software as a human endeavor and emphasizes knowing what code to write.](https://assets.ai.engineer/sites/aiecode2025/sha256/2bd992fc1d4bfc57894b5651260dc3f8d4ef9162671b5c25ea0ed5d89c8a8941.webp)

Your Competitive Advantage

Dijkstra's generation faced their software crisis with discipline: they invented software engineering.

Brooks faced his with wisdom: he warned us there would be no silver bullet.

Now we face ours with infinite generation. The solution isn't another tool or methodology.

It's remembering what we've always known: Software is a human endeavor.
The hard part was never typing the code. It was knowing what to type.

Broadcast text:
AIE / CODE
PRESENTED BY
Google DeepMind
THE INFINITE SOFTWARE CRISIS
JAKE NATIONS / Staff Software Engineer
NETFLIX

[18:16](https://www.youtube.com/watch?v=eIoohUmYpGI&t=1096s) [Slide argues that software is a human endeavor and that knowing what to build matters more than typing code.](https://assets.ai.engineer/sites/aiecode2025/sha256/116a953bff0c4deda228071845beedf26ba4b827b9f2c563f5e240d9507b8467.webp)

Your Competitive Advantage

Dijkstra's generation faced their software crisis with discipline: they invented software engineering.

Brooks faced his with wisdom: he warned us there would be no silver bullet.

Now we face ours with infinite generation. The solution isn't another tool or methodology.

It's remembering what we've always known: Software is a human endeavor.
The hard part was never typing the code. It was knowing what to type.

Broadcast text:
AIE / CODE
PRESENTED BY
Google DeepMind
THE INFINITE SOFTWARE CRISIS
JAKE NATIONS / Staff Software Engineer
NETFLIX

### Understanding Our Systems

Nations closes with a challenge: as AI writes most of the code, developers must still understand the systems they build.

[18:22](https://www.youtube.com/watch?v=eIoohUmYpGI&t=1102s) [Slide asks whether people will still understand their systems when AI writes most of the code.](https://assets.ai.engineer/sites/aiecode2025/sha256/7d59ef42ce790dc6b79cd4c77240c5f26dd10cf21d321cfbcd36dabb701e2016.webp)

The question isn't whether we'll use AI.

The question is whether we'll still understand our own systems when AI is writing most of the code.

AIE / CODE
PRESENTED BY
Google DeepMind

THE INFINITE SOFTWARE CRISIS
JAKE NATIONS / Staff Software Engineer
NETFLIX

### AI Engineer Code Summit

[18:49](https://www.youtube.com/watch?v=eIoohUmYpGI&t=1129s) [AI Engineer Code Summit logo and website on a black background.](https://assets.ai.engineer/sites/aiecode2025/sha256/ba831374c8d4c7fba63bb9b0241f7391de447cf1086ad5d87bd3e5ce5586e03d.webp)

AI Engineer
Code Summit

https://ai.engineer

## Full transcript

[0:12](https://www.youtube.com/watch?v=eIoohUmYpGI&t=12s) [upbeat electronic music] Hey everyone, good afternoon. Um, I'm gonna start my talk with a bit of a confession. Uh, I shipped code I didn't quite understand.

[0:29](https://www.youtube.com/watch?v=eIoohUmYpGI&t=29s) Generated it, tested it, deployed it, couldn't explain how it worked. And here's the thing, though, I'm willing to bet every one of you have too. [audience laughing]

[0:40](https://www.youtube.com/watch?v=eIoohUmYpGI&t=40s) So now that we can all admit that we all ship code that we don't understand anymore, I wanna take a bit of a journey, see how this kind of has come to be.

[0:46](https://www.youtube.com/watch?v=eIoohUmYpGI&t=46s) First, look back in history. We see that history tends to repeat itself. Second, we've fallen into a bit of a trap. We've confused easy with simple. Lastly, there is a fix, but it requires us not to outsource our thinking.

[1:01](https://www.youtube.com/watch?v=eIoohUmYpGI&t=61s) So I spent the last few years at Netflix helping drive adoption of AI tools, and I have to say the acceleration is absolutely real. Backlog items that used to take days now take hours, and large refactors that have been on the books for years are finally being done.

[1:15](https://www.youtube.com/watch?v=eIoohUmYpGI&t=75s) Here's the thing, though. Large production systems always fail in unexpected ways, like look what happened with Cloudflare recently. When they do, you better understand the code you're debugging, and the problem is now we're generating code at such speed and such volume, our understanding is having a hard time keeping up.

[1:32](https://www.youtube.com/watch?v=eIoohUmYpGI&t=92s) Hell, I know I've done it myself. I've generated a bunch of code, looked at it and thought, "I, I have no idea how this-- what this does." But, you know, the tests pass, it works, so I shipped it.

[1:42](https://www.youtube.com/watch?v=eIoohUmYpGI&t=102s) The thing here is this isn't really new. Every generation of software engineers has eventually hit a wall where software complexity has exceeded their ability to manage it. We're not the phase-- first to face a software crisis, we're the first to face it at this infinite scale of generation.

[1:56](https://www.youtube.com/watch?v=eIoohUmYpGI&t=116s) So let's take a step back to see where this all started.

[1:59](https://www.youtube.com/watch?v=eIoohUmYpGI&t=119s) In the late '60s, early '70s, a bunch of smart computer scientists at the time came together and said, "Hey, we're in a software crisis. We have this huge demand for software, and yet we're not really able to keep up and, like, projects are taking too long, and it's just really slow.

[2:15](https://www.youtube.com/watch?v=eIoohUmYpGI&t=135s) We're not doing a good job." So Dijkstra kinda came up with a really great quote, and he said, "When we had a few weak computers," and I mean to paraphrase the longer quote, "When we had a few weak com- computers, programming was a mild problem, and now with gigantic computers, programming has become a gigantic problem."

[2:30](https://www.youtube.com/watch?v=eIoohUmYpGI&t=150s) He was explaining as hardware power grew by a factor of a thousand, society's wants of software grew in proportion. And so it left us, the programmers, to figure out between the ways and the means, how do we support this much more software?

[2:44](https://www.youtube.com/watch?v=eIoohUmYpGI&t=164s) So this kinda keeps happening in a cycle. In the '70s, we get the C programming language, so we could write bigger systems. The '80s, we have personal computers. Now everyone can write software.

[2:53](https://www.youtube.com/watch?v=eIoohUmYpGI&t=173s) In the '90s, we get object-oriented programming. Inheritance hierarchies from hell were... You know, thanks Java for that. In the 2000s, we get Agile, and we have sprints and scrum masters telling us what to do.

[3:05](https://www.youtube.com/watch?v=eIoohUmYpGI&t=185s) There's no more waterfall. In the 2010s, we had cloud, mobile, DevOps, you know everything. Software truly ate the world.

[3:13](https://www.youtube.com/watch?v=eIoohUmYpGI&t=193s) And today, now we have AI. You know, Copilot, Cursor, Claude, Codex, Gemini, you name it. We can generate code as fast as we can describe it. The pattern continues, but the scale has really changed.

[3:22](https://www.youtube.com/watch?v=eIoohUmYpGI&t=202s) It's, it's infinite now. So, uh, Fred Brooks, who you might know him from writing The Mythical Man-Month, he also wrote a paper in 1986 called No Silver Bullet, and in this, he argued that there'd be no single innovation that would give us an order of magnitude improvement in software productivity.

[3:39](https://www.youtube.com/watch?v=eIoohUmYpGI&t=219s) Why? Because he said the hard part wasn't in ever the mechanics of coding, the syntax, the typing, the boilerplate. It was about understanding the actual problem and designing the solution, and no tool can eliminate that fundamental difficulty.

[3:52](https://www.youtube.com/watch?v=eIoohUmYpGI&t=232s) Every tool and technique we've created up until this point makes the mechanics easier. The core challenge, though, understanding what to build, how it should work, remains just as hard.

[4:03](https://www.youtube.com/watch?v=eIoohUmYpGI&t=243s) So if the problem isn't in the mechanics, why do we keep optimizing for it? How do experienced engineers end up with code they don't understand now? The answer, I think, comes down to two words we tend to confuse, simple and easy.

[4:14](https://www.youtube.com/watch?v=eIoohUmYpGI&t=254s) We tend to use them interchangeably, but they really mean completely different things. Uh, I was outed at the speaker dinner as being a Clojure guy, so this is kind of clear here, but Rich Hickey, the creator of the Clojure programming language, explained this in his talk from 2011 called Simple Made Easy.

[4:29](https://www.youtube.com/watch?v=eIoohUmYpGI&t=269s) He defined simple meaning one fold, one braid, and no entanglement. Each piece does one thing and doesn't intertwine with others. He defines easy as meaning adjacent, what's within reach.

[4:39](https://www.youtube.com/watch?v=eIoohUmYpGI&t=279s) What can you access without effort? Copy, paste, ship. Simple is about structure. Easy is about proximity.

[4:48](https://www.youtube.com/watch?v=eIoohUmYpGI&t=288s) The thing is, we can't make something simple by wishing it so. Simplicity requires thought, design, and untangling. But we can always make something easier. You just put it closer.

[4:57](https://www.youtube.com/watch?v=eIoohUmYpGI&t=297s) Install a package. Generate it with AI. You know, copy a solution off of Stack Overflow. It's hu-- It's human nature to take the easy path. We're wired for it.

[5:07](https://www.youtube.com/watch?v=eIoohUmYpGI&t=307s) You know, as I said, copy something from Stack Overflow. It's right there. Framework that handles everything for you with magic? Install and go. But easy doesn't mean simple. Easy means you can add to your system quickly.

[5:18](https://www.youtube.com/watch?v=eIoohUmYpGI&t=318s) Simple means you can understand the work that you've done. Every time we choose easy, we're choosing speed now, complexity later, and honestly,

[5:25](https://www.youtube.com/watch?v=eIoohUmYpGI&t=325s) that trade-off really used to work. The complexity accumulated in our codebases slowly enough that we can refactor, rethink, and rebuild when needed. I think AI has destroyed that balance 'cause it's the ultimate easy button.

[5:37](https://www.youtube.com/watch?v=eIoohUmYpGI&t=337s) It makes the easy path so frictionless that we don't even consider the simple one anymore. Why think about architecture when code appears instantly?

[5:46](https://www.youtube.com/watch?v=eIoohUmYpGI&t=346s) So let me show you how this happens, how a simple task evolves into a mess of complexity through a conversational interface that we've all come to love. You know, this is a contrived example, but, you know, say we have our app, we wanna add, uh, some authentication to it.

[5:58](https://www.youtube.com/watch?v=eIoohUmYpGI&t=358s) We say add auth, so we get a nice clean auth.js file. Iterate on it a few times, it gives a message five. You're like, "Okay, cool. We're gonna add OAuth now too," because...

[6:05](https://www.youtube.com/watch?v=eIoohUmYpGI&t=365s) And now we've got an auth.js and OAuth.js. We keep iterating. You know, we find ourselves that sessions are broken.

[6:11](https://www.youtube.com/watch?v=eIoohUmYpGI&t=371s) And we got a bunch of conflicts. And by the time you get to turn 20, you're not really having a discussion anymore. You're managing context that's become so complex that even you don't remember all the constraints that you've added to it.

[6:20](https://www.youtube.com/watch?v=eIoohUmYpGI&t=380s) Dead code from abandoned approaches, uh, tests that got fixed by just making them work. You know, fragments of three different solutions because you kept saying, "Wait, actually." Each new instruction is overwriting architectural patterns.

[6:31](https://www.youtube.com/watch?v=eIoohUmYpGI&t=391s) We said make the auth work here. It did. And we said fix this error. It did. There's no resistance to bad architectural decisions. The code just morphs to satisfy your latest request.

[6:40](https://www.youtube.com/watch?v=eIoohUmYpGI&t=400s) Each interaction is choosing easy over simple, and easy always means more complexity. We know better, but when the easy path is just this easy, we take it, and complexity is going to compound until it's too late.

[6:55](https://www.youtube.com/watch?v=eIoohUmYpGI&t=415s) AI really takes easy to its logical extreme. Decide what you want, get code instantly. But here's the danger in that. The generated code treats every pattern in your codebase the same.

[7:07](https://www.youtube.com/watch?v=eIoohUmYpGI&t=427s) You know, when an agent analyzes your codebase, every line becomes a pattern to preserve. The authentication check on line 47, that's a pattern. That weird gRPC code that's acting like GraphQL that I may have had in 2019, that's also a pattern.

[7:19](https://www.youtube.com/watch?v=eIoohUmYpGI&t=439s) Technical debt doesn't register as debt. It's just more code. The real problem here is complexity. I know I've been saying that word a bunch in this talk without really defining it, but the best way to think about it is it's the opposite of simplicity.

[7:31](https://www.youtube.com/watch?v=eIoohUmYpGI&t=451s) It just means intertwined. And when things are complex, everything touches everything else. You can't change one thing without affecting 10 others.

[7:41](https://www.youtube.com/watch?v=eIoohUmYpGI&t=461s) So back to Fred Brooks' No Silver Bullet paper. In it, he identified that there's two main types of complexity in every system. There's the essential complexity, which is really the fundamental difficulty of the actual problem you're trying to solve.

[7:53](https://www.youtube.com/watch?v=eIoohUmYpGI&t=473s) Users need to pay for things. Orders must be fulfilled. This is the complexity of why your software system exists in the first place. And then second, there's this idea of accidental complexity.

[8:03](https://www.youtube.com/watch?v=eIoohUmYpGI&t=483s) Everything else we've added along the way, workarounds, defensive code, frameworks, abstractions that made sense a while ago. It's all the stuff that we put together to make the code itself work.

[8:13](https://www.youtube.com/watch?v=eIoohUmYpGI&t=493s) In a real codebase, these two types of complexity are everywhere, and they get so tangled together that separating them requires context, history, and experience.

[8:21](https://www.youtube.com/watch?v=eIoohUmYpGI&t=501s) The generated output makes no such distinction, and so every pattern is-- keeps just getting preserved.

[8:29](https://www.youtube.com/watch?v=eIoohUmYpGI&t=509s) So here's a real example from, uh, some work we're doing at Netflix. I have a system that has a abstraction layer sitting between our old authorization code we wrote, say, five or so years ago and a new centralized auth system.

[8:41](https://www.youtube.com/watch?v=eIoohUmYpGI&t=521s) We didn't have time to rebuild our whole app, so we just kinda put a shim in between. So now we have AI. This is a great opportunity to refactor our code to use the new system directly.

[8:49](https://www.youtube.com/watch?v=eIoohUmYpGI&t=529s) Seems like a simple request, right? Uh, no. It's like the old code was just so tightly coupled to its authorization patterns. Like, we had permission checks woven through business logic, role assumptions baked into data models, and auth calls scattered across hundreds of files.

[9:04](https://www.youtube.com/watch?v=eIoohUmYpGI&t=544s) The agent would start refactoring, get a few files in and hit a dependency it couldn't untangle, and just spiral out of control or give up, or worse, it would try and preserve some existing logic that-- from the old system and recreating it using the new system, which I think is not great too.

[9:21](https://www.youtube.com/watch?v=eIoohUmYpGI&t=561s) The thing is, it couldn't see the seams. It couldn't identify where the business logic ended and the auth logic began. Everything was so tangled together that even with perfect information, the AI couldn't find a clean path through.

[9:33](https://www.youtube.com/watch?v=eIoohUmYpGI&t=573s) When your accidental complexity gets this tangled, AI's not the best help to actually make it any better. I found it only adds more layers on top.

[9:42](https://www.youtube.com/watch?v=eIoohUmYpGI&t=582s) We can tell the difference, or at least we can when we slow down enough to think. We know which patterns are essential and which are just how someone solved it a few years ago.

[9:50](https://www.youtube.com/watch?v=eIoohUmYpGI&t=590s) We carry the context that the AI can't infer, but only if we time to make-- take time to make these distinctions before we start.

[9:59](https://www.youtube.com/watch?v=eIoohUmYpGI&t=599s) So how do you actually do it? How do you separate the accidental and essential complexity when you're staring at a huge codebase? The codebase I work on at Netflix has around a million lines of Java, and the main service in it is about five million tokens last time I checked.

[10:13](https://www.youtube.com/watch?v=eIoohUmYpGI&t=613s) No context window I have access to, uh, can hold it. So when I wanted to work with it, I first thought, "Hey, maybe I can just copy large swaths of this codebase into the, into the context and see if the patterns would emerge, see if it would just be able to figure out what's happening."

[10:26](https://www.youtube.com/watch?v=eIoohUmYpGI&t=626s) And just like the authorization refactor from previously, it's-- the output just got lost in its own complexity. So with this, I was forced to do something different. I had to, to select what to include, design docs, architecture diagrams, key interfaces, you name it, and take time writing out the requirements of how components should interact and what patterns

[10:42](https://www.youtube.com/watch?v=eIoohUmYpGI&t=642s) to follow. See, I was writing a spec. Uh, five million tokens became two thousand words of specification. And then to take it even further, take that spec and create an exact step-- set of steps of code to execute.

[10:55](https://www.youtube.com/watch?v=eIoohUmYpGI&t=655s) No vague instructions, just a precise sequence of operations. I found this produced much cleaner and more focused code that I could understand, as I defined it first and planned its own execution.

[11:08](https://www.youtube.com/watch?v=eIoohUmYpGI&t=668s) This became the approach which I called context compression a while ago, but you call it context engineering or spec-driven development, whatever you want. The name doesn't matter. What only matters here is that thinking and planning become a majority of the work.

[11:20](https://www.youtube.com/watch?v=eIoohUmYpGI&t=680s) So let, let me walk you through the-- how this works in practice.

[11:24](https://www.youtube.com/watch?v=eIoohUmYpGI&t=684s) So you have step one, phase one, research. You know, I go and feed everything into it up front. Architecture diagrams, documentation, Slack threads. I mean, been over this a bunch.

[11:32](https://www.youtube.com/watch?v=eIoohUmYpGI&t=692s) But really just bring as much context as you can that's gonna be relevant to the changes you're making. And then use the agent to analyze the codebase and map out the components and dependencies.

[11:42](https://www.youtube.com/watch?v=eIoohUmYpGI&t=702s) This shouldn't be a one-shot process. I like to probe. Say, like, "What about the caching? How does this handle failures?" And when its analysis is wrong, I'll correct it, and if it's missing context, I provide it.

[11:51](https://www.youtube.com/watch?v=eIoohUmYpGI&t=711s) Each iteration refines its analysis. The output here is a single research document. Here's what exists, here's what connects to what, and here's what your change will affect. Hours of exploration are compressed into minutes of reading.

[12:05](https://www.youtube.com/watch?v=eIoohUmYpGI&t=725s) I know Dex mentioned it this morning, but the human checkpoint here is critical. This is where you validate the analysis against reality, the highest leverage moment in the entire process.

[12:15](https://www.youtube.com/watch?v=eIoohUmYpGI&t=735s) Catch errors here, prevent disasters later. On to phase two. Now that you have some valid research in hand, we create a detailed implemen- implementation plan, real code structure, function signatures, type definitions, data flow.

[12:28](https://www.youtube.com/watch?v=eIoohUmYpGI&t=748s) You want this to be so any developer can follow it. I, I kind of liken it to paint by numbers. You should be able to hand it to your most junior engineer and say, "Go do this."

[12:35](https://www.youtube.com/watch?v=eIoohUmYpGI&t=755s) And if they copy it line by line, it should just work.

[12:40](https://www.youtube.com/watch?v=eIoohUmYpGI&t=760s) This step is where we make a lot of the important architectural decisions. You know, make sure complex logic is correct, make sure business requirements are, you know, following good practice, make sure there's good service boundaries, clean separation, and preventing any unnecessary coupling.

[12:54](https://www.youtube.com/watch?v=eIoohUmYpGI&t=774s) We spot the problems before they happen because we've lived through them. AI doesn't have that option. It treats every pattern as a requirement.

[13:02](https://www.youtube.com/watch?v=eIoohUmYpGI&t=782s) The real magic in this step is the review speed. We can validate this plan in minutes and know exactly what's going to be built. And in order to keep up with the speed of, speed at which we wanna generate code, we need to be able to comprehend what we're doing just as fast.

[13:18](https://www.youtube.com/watch?v=eIoohUmYpGI&t=798s) Lastly, we have implementation, and now that we have a clear plan and, like, backed by clear research, this phase should be pretty simple, and that's the point. You know, when AI has a clear specification to follow, the context remains clean and focused.

[13:32](https://www.youtube.com/watch?v=eIoohUmYpGI&t=812s) We've prevented the complexity spiral of long conversations, and instead of 50 messages of evolutionary code, we have 30 focused outputs, each validated before proceeding. No abandoned approaches, no conflicting patterns, no wait, actually moments that leave dead code everywhere.

[13:48](https://www.youtube.com/watch?v=eIoohUmYpGI&t=828s) To me, what I see as a real payoff of this is that you can use a background agent to do a lot of this work 'cause you've done all the thinking and hard work ahead of time.

[13:56](https://www.youtube.com/watch?v=eIoohUmYpGI&t=836s) It can just start the implementation. You can go work on something else and come back to review, and you can review this quickly because you're just verifying that it's conforming to your plan, not trying to understand if anything got invented.

[14:10](https://www.youtube.com/watch?v=eIoohUmYpGI&t=850s) The thing here is we're not using AI to think for us. We're using it to accelerate the mechanical parts while maintaining our ability to understand it. Research is faster, planning is more thorough, and the implementation is cleaner.

[14:21](https://www.youtube.com/watch?v=eIoohUmYpGI&t=861s) The thinking, the synthesis, and the judgment, though, that remains with us.

[14:29](https://www.youtube.com/watch?v=eIoohUmYpGI&t=869s) So remember that, uh, authorization refactor I said that AI couldn't handle? The thing is now we're actually, you know, working on it now and starting to make some good progress on it.

[14:39](https://www.youtube.com/watch?v=eIoohUmYpGI&t=879s) The thing is, it's not because we found better prompts. We found we couldn't even jump into doing any sort of research, planning, and implementation. We actually had to go make this change ourself by hand.

[14:49](https://www.youtube.com/watch?v=eIoohUmYpGI&t=889s) No AI, just reading the code, understanding dependencies, and making changes to see what broke. That manual migration was, uh, I'll be honest, was a pain, but it was crucial.

[14:59](https://www.youtube.com/watch?v=eIoohUmYpGI&t=899s) It revealed all the hidden constraints, which invariants had to hold true, and which services would break if the auth changed, things no amount of code ana- analysis would've surfaced for us.

[15:09](https://www.youtube.com/watch?v=eIoohUmYpGI&t=909s) And then we fed that pull request of the actual manual migration into our research process and had it use that as the seed for any sort of research going forward.

[15:19](https://www.youtube.com/watch?v=eIoohUmYpGI&t=919s) The AI could then see what a clean migration looks like. The thing is, each of these entities are slightly different, so we have to go and interrogate it and say, "Hey, what do we about...

[15:28](https://www.youtube.com/watch?v=eIoohUmYpGI&t=928s) do about this?" Some things are encrypted, some things are not. We had to provide that extra context each time, uh, through a bunch of iteration.

[15:37](https://www.youtube.com/watch?v=eIoohUmYpGI&t=937s) Then, and only then, we could generate a plan that might work in one shot, and the keyword... and might's the key word here is we're still validating, still adjusting, and still discovering edge cases.

[15:51](https://www.youtube.com/watch?v=eIoohUmYpGI&t=951s) The three-phase approach is not magic. It only works because we did this one migration by hand. We had to earn the understanding before we can encode into our process.

[16:01](https://www.youtube.com/watch?v=eIoohUmYpGI&t=961s) I still think there's no silver bullet. I don't think there's better prompts, better models, or even writing better specs, just the work of understanding your system deeply enough that you can make changes to it safely.

[16:14](https://www.youtube.com/watch?v=eIoohUmYpGI&t=974s) So why go through with all this? Like, why not just iterate with AI until it works? Like, eventually, won't models get strong enough and it just works? The thing to me is it works isn't enough.

[16:24](https://www.youtube.com/watch?v=eIoohUmYpGI&t=984s) There's a difference between code that passes test and code that survives in production, between systems that function today and systems that, that can be changed by someone else in the future.

[16:35](https://www.youtube.com/watch?v=eIoohUmYpGI&t=995s) The real problem here is a knowledge gap. When AI can generate thousands of lines of code in seconds, understanding it could take you hours, maybe days if it's complex.

[16:46](https://www.youtube.com/watch?v=eIoohUmYpGI&t=1006s) Who knows? Maybe never if it's really that tangled. And here's something that I don't think many people are even talking about at this point. Every time we skip thinking to keep up with generation speed, we're not just adding code that we don't understand.

[16:58](https://www.youtube.com/watch?v=eIoohUmYpGI&t=1018s) We're losing our ability to recognize problems. That instinct that says, "Hey, this is getting complex," it atrophies when you don't understand your own system.

[17:09](https://www.youtube.com/watch?v=eIoohUmYpGI&t=1029s) Pattern recognition comes from experience. When I spot a dangerous architecture, it's because I'm the one up at 3:00 in the morning dealing with it. When I push for simpler solutions, it's because I've had to maintain the alternative from someone else.

[17:21](https://www.youtube.com/watch?v=eIoohUmYpGI&t=1041s) AI generates what you ask it for. It doesn't encode lessons from past failures.

[17:27](https://www.youtube.com/watch?v=eIoohUmYpGI&t=1047s) The three-phase approach bridges this gap. It compresses understanding into artifacts we can review at the speed of generation. Without it, we're just accumulating complexity faster than we can comprehend it.

[17:40](https://www.youtube.com/watch?v=eIoohUmYpGI&t=1060s) AI changes everything about how we write code, but honestly, I don't think it changes anything about why software itself fails. Every generation has faced their own software crisis. Dijkstra's generation faced it by creating the discipline of software engineering, and now we face ours with infinite code generation.

[17:58](https://www.youtube.com/watch?v=eIoohUmYpGI&t=1078s) I don't think the solution is another tool or methodology. It's remembering what we've always known, that software is a human endeavor. The hard part was never typing the code.

[18:06](https://www.youtube.com/watch?v=eIoohUmYpGI&t=1086s) It was knowing what to type in the first place. The developers who thrive won't just be the ones who generate the most code. They'll be the ones who understand what they're building, who can still see the seams, who can recognize that they're solving the wrong problem.

[18:19](https://www.youtube.com/watch?v=eIoohUmYpGI&t=1099s) That's still us. That will only be us.

[18:23](https://www.youtube.com/watch?v=eIoohUmYpGI&t=1103s) I wanna leave on a question, and I don't think the question is whether or not we will use AI. That's a foregone conclusion. The ship has already sailed. To me, the question's gonna be whether we will still understand our own systems when AI is writing most of our code.

[18:37](https://www.youtube.com/watch?v=eIoohUmYpGI&t=1117s) Thank you. [upbeat music]
