# The engineer of the future is the person who is able to choose what is worth doing — Addy Osmani

Addy Osmani

AI Engineer World's Fair 2026

[Talk page](https://ai.engineer/talks/n97BCfyFIvw-engineer-future-is-person-who-is-able) · [Video](https://www.youtube.com/watch?v=n97BCfyFIvw)

## The engineer of the future is the person who is able to choose what is worth doing

As agents take on more software work, engineering shifts toward choosing worthwhile problems, designing verification, and remaining answerable for what ships.

### What is worth doing, and who stands behind it?

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

Should this work ship? Should it be blocked, redirected, or accepted with a known risk? Those production decisions remain consequential even when an agent does most of the implementation. Addy Osmani opens with the human responsibility behind them: choosing what is worth doing, then owning the evidence, the understanding, and the verdict around automated work.

![Black slide with white, yellow, and purple text describing the engineer’s role in increasingly automated work, with the speaker inset at left.](https://ai.engineer/api/talk-essay-media/820339da57e8deaf134f845a6fbffad9450450922262ef5d58b0b1c5ef8fb38f)

Engineers choose what is worth doing and own the evidence, understanding, and verdict.

**Quality produces evidence; a verdict assigns responsibility.** Tests and other checks help establish whether work meets a standard. Someone still has to decide what that evidence warrants and remain answerable for the decision. Keeping a human in the loop means preserving that responsibility, not simply arranging for a person to see the output.

This changes how engineering roles fit together. Osmani credits Boris Cherny with useful language for craft boundaries that are becoming blurry: ownership increasingly follows the work rather than a job title. Prototype, build, sweep, grow, and maintain are distinct engineering modes, and agents can help with all of them. The scarce judgment is deciding which mode the product needs, what quality bar applies, and who owns the result.

### From a model to a software factory

[2:33](https://www.youtube.com/watch?v=n97BCfyFIvw&t=153s)

A model alone is not the whole coding system. **Harness engineering** surrounds it with context, tools, a filesystem, and Git—the environment that makes its capabilities usable for delegated work. **Loop engineering** adds repeated prompting, checking, remembering, and decisions about what happens next. Instead of asking for one answer, the engineer designs a process that can continue working. That is where agents begin to behave like infrastructure.

Put those pieces together and the result is a software factory, a concept Osmani connects to Dex’s earlier talk. Agents operate inside the execution loop and produce evidence. Humans make the production decisions around it. The purpose is to move human judgment to the checkpoints where it has the greatest effect, rather than requiring continuous intervention in every execution step.

### Clean code helps the next agent

[3:35](https://www.youtube.com/watch?v=n97BCfyFIvw&t=215s)

As AI-assisted code becomes an ordinary part of repositories, answerability becomes an engineering requirement. Osmani cites Sonar’s [2026 State of Code Developer Survey](https://www.sonarsource.com/state-of-code-developer-survey-report.pdf) to illustrate that shift. Maintainability matters for the same reason it always has—someone must be able to understand the code—but the next reader may now be an agent as well as a teammate.

The Sonar study [Does Code Cleanliness Affect Coding Agents?](https://arxiv.org/abs/2605.20049) separates task success from the cost of reaching it. In the controlled comparison using Claude Code with **Sonnet 4.6**, clean repositories had roughly the same task pass rates as messy repositories, with 7–8% fewer tokens and about 34% fewer file revisits. These are results from the studied repository pairs and tasks, with variation across tasks, rather than a guarantee for every agent or codebase. The useful distinction is that an agent can reach a similar result while spending less effort reading and revisiting the system.

![Slide reading “Clean code is cheaper for agents to read,” with a yellow line stating “7–8% fewer tokens. 34% fewer file revisits. Same pass rate.”](https://ai.engineer/api/talk-essay-media/c3f0a1dccd5ec7d7f60941d890f97ce869e63cbeabb0088d6c9d773ef23b09de)

Clean code is cheaper for agents to read: 7–8% fewer tokens, 34% fewer file revisits, same pass rate.

### Distrust without bandwidth

[4:21](https://www.youtube.com/watch?v=n97BCfyFIvw&t=261s)

Making generation cheaper does not automatically make review cheaper. Engineers can be skeptical of AI-generated code and still lack the capacity to check everything it produces. In Sonar’s survey, 96% of respondents did not fully trust the functional correctness of AI-generated code, while 48% completely agreed that they always check AI-assisted code before committing. These are reported attitudes and practices, not observed defect rates; the second figure does not mean everyone else never checks. Osmani’s concern is the gap between distrust and the bandwidth to act on it.

**Verification must become cheaper, clearer, and harder to skip.** At organizational scale, adoption can move faster than governance, leaving review and validation as bottlenecks. A useful record of delegated work must let someone answer several connected questions: Did a model touch this file? What constraints guided it? What evidence did it produce? What risk was accepted, and who owns the result?

Osmani briefly invokes Homer Simpson’s computer automation as the comic version of a future with little human involvement. The serious problem is that an agent can produce more change than a person can comprehend. When generation scales faster than comprehension, judgment backed by evidence becomes scarce.

### Alpha, decay, and taste that can be taught

[6:06](https://www.youtube.com/watch?v=n97BCfyFIvw&t=366s)

Where does human judgment continue to create value? Osmani introduces two terms for thinking about that question. **Alpha** is the gap between what a person can do today and what current models can do. **Decay** is the clock on that gap. A capability can be valuable without remaining a durable advantage as the model frontier advances.

Taste is one proposed answer. Osmani attributes to Paul Graham the observation that when making things becomes easier, choosing what to make becomes more important. But taste can also become a vague name for work that has not yet been explained. He favors a definition he attributes to Mitchell Hashimoto: the ability to make high-quality qualitative judgments where an objective metric does not yet exist. That places taste before a benchmark can settle the question, or before the market has fully expressed a preference.

Model-generated interfaces make this concrete. Looking at the UX an agent creates, a person may recognize that an experience works—or that something is wrong—before having a metric for the difference. If generating ten options is cheap, the valuable contribution is choosing which option deserves to exist. To improve future decisions, that judgment must become critique and examples that a team or system can learn from. Taste remains useful, but treating it as an eternal moat misses how learning works.

The decay test applies across the capabilities engineers have relied on:

| Capability | What changes its advantage |
|---|---|
| Speed | Models absorb more execution work. |
| Recall | Harnesses provide memory. |
| Verification | Evals, static checks, and model critique move into the harness. |
| Taste | Models learn from examples and preferences. |

Osmani expects taste to decay more slowly, but even judgment is a slope rather than an impermeable boundary. The career strategy is to keep moving to the next level of responsibility instead of defending one capability forever.

That shifts the question from what an agent cannot do to what a human must be answerable for. More people can now make computers do useful things, expanding access to building software. Engineering still requires reasoning about systems, understanding constraints, defending trade-offs, managing risk, and being reachable when something breaks. Those responsibilities extend beyond producing an implementation.

### A passing build can conceal lost understanding

[9:48](https://www.youtube.com/watch?v=n97BCfyFIvw&t=588s)

**Cognitive debt** is the erosion of understanding and memory as more problem solving is deferred to AI. In a repository, it appears as a gap between how much code exists and how much any human on the team understands. A build can pass its tests and a PR can be ready to merge while the team loses its ability to explain the system it is shipping. Passing checks and retaining comprehension are different properties.

Delegation depth makes this harder. A thirty-second agent run feels like an interaction; a task that runs for an hour or a day is a workstream. An agent can remain inside the system long enough for the human to lose the thread, especially when several long tasks run in parallel. Review at that scale cannot be a glance at the final result. It has to become a control system.

![Slide with three horizontal bars labeled greater than 30 minutes, one hour, and eight hours of human-equivalent tasks, showing 80.6%, 70.2%, and 25.6%, plus a greater-than-60-hour callout.](https://ai.engineer/api/talk-essay-media/39cb4f32a87b5d7dac633a2be084862e90a1618b94f76c526be77c641ecc50c5)

Delegation depth is now real: long, parallel tasks demand answerable delegation.

### Borrowed confidence and the orchestration tax

[11:04](https://www.youtube.com/watch?v=n97BCfyFIvw&t=664s)

**Cognitive surrender** goes further than losing familiarity with code: it means accepting an AI answer before forming an independent judgment. Delegation asks the agent to do the work and return enough evidence for a person to judge it. Surrender substitutes the agent’s answer for that judgment.

Osmani cites Wharton research as a warning about borrowed confidence. In the cited reasoning experiments, participants accepted the incorrect AI output in 73.2% of trials where they consulted AI and it supplied a wrong answer. The research also reports increased confidence following errors. These were reasoning experiments, not software-review measurements, but they illustrate why confidence in an answer cannot substitute for evidence about its correctness.

A third failure mode is **orchestration tax**. Running hundreds or thousands of agents does not create more human attention. Every additional loop introduces decisions about routing, merging, verification, and integration. Human cognitive bandwidth does not parallelize with the agent count.

The corrective is not necessarily to run fewer agents. It is to design attention deliberately: where a person enters the process, what information they acquire there, and what they can reuse. Parallel execution only helps if the resulting decisions remain manageable.

### Accountability makes delegation scalable

[12:38](https://www.youtube.com/watch?v=n97BCfyFIvw&t=758s)

Accountability can sound like an extra burden, but it is what allows the larger system to scale. As agents do more work, faster and in parallel, someone must explain the intent, inspect the evidence, accept the risk, and improve the system when a decision turns out to be wrong.

Osmani frames the career distinction as the half-life of an edge versus the half-life of a signature. An advantage in speed, recall, verification, or taste might disappear with a model release; that is a strategic metaphor, not a measured duration. A signature is the person, team, or institution standing behind the shipped work. Credibility built through that responsibility can last longer than any particular capability advantage. Skills create leverage; accountability turns it into trust.

Agents can choose, route, merge, escalate, and operate within policy. In many systems, they should. But authority to execute does not transfer responsibility for consequences. An agent can follow a runbook without becoming the party that bears the cost when it fails. The questions remain: Who understood the policy? Who accepted the risk? Who owns the blast radius?

**High agency** means actively owning outcomes: knowing when to delegate, inspect, stop, and put your name on the result. Personally doing everything does not scale. Osmani’s agency ladder moves from flagging a problem through executing, diagnosing, proposing, recommending, and resolving it. The final step is discernment—deciding whether the problem deserves investment at all. When agents make more paths possible, choosing not to pursue one can be the responsible decision.

### The handoff is evidence and responsibility

[15:07](https://www.youtube.com/watch?v=n97BCfyFIvw&t=907s)

The operating model separates an inner execution loop from an outer engineering loop:

| Loop | Work | Role |
|---|---|---|
| Inner | Investigate, implement, test, report | Exercise capability. |
| Outer | Decide, verify, approve, own | Exercise agency. |

Agents can run much more of the inner loop. The outer loop determines which work deserves attention and what can responsibly reach production.

The agent’s handoff is an evidence package appropriate to the task: diffs, tests, logs, rationale, traces, trajectories, or screenshots. The engineer then decides whether the work was worth doing, whether the evidence is sufficient, and whether to approve or redirect it. Whoever approves the result must own what reaches production. This boundary applies whether a team uses a few agents or thousands: seeing AI output is not the same as accepting responsibility on the basis of evidence.

Osmani makes the release rule explicit: **“Explain it or don't ship it.”** This does not require a human to type every line or even read every line. It requires someone to understand the work well enough to defend it.

Ownership files in large codebases provide a familiar analogy. Particular directories or architectural areas have people who are on the hook for them. Agent-written changes still need that relationship between a system and its accountable owners. Before release, those owners must be able to explain the changes, identify the supporting evidence, and understand the risks they are accepting.

### Cheaper software expands the work of engineering

[16:52](https://www.youtube.com/watch?v=n97BCfyFIvw&t=1012s)

Automation raises the floor, and engineering moves up a level. The work increasingly includes **loop design**, **evidence design**, and **brownfield stewardship**—caring for existing systems while agents change them. Fewer keystrokes leave more software surface area needing taste, verification, ownership, and care.

Osmani closes with an optimistic historical analogy. Higher-level languages, frameworks, cloud, and low-code tools made software easier to create. Lower costs brought previously infeasible ideas within reach, revealing latent demand. He expects agents to extend that pattern: more software becomes possible, and the bottleneck moves from whether it can be built to whether it should exist and whether someone can answer for it. That demand expansion is his forecast, with engineering responsibility at its center.

![Purple-and-black closing slide stating that easier software writing led to exponentially more software, with a yellow sentence about making agent work legible, verifiable, and worth shipping.](https://ai.engineer/api/talk-essay-media/84d684c1089309d0a234bf0304bf717a1d9b50091e2168d78381d91a323ec780)

Easier software creation leads to more software; engineers make agent work legible, verifiable, and worth shipping.

Build the factories, keep the lights on, and own the verdict.

## Resources

- [State of Code Developer Survey, 2026](https://www.sonarsource.com/state-of-code-developer-survey-report.pdf) — Sonar's survey report on AI-assisted coding, developer trust and verification practices.
- [Does Code Cleanliness Affect Coding Agents?](https://arxiv.org/abs/2605.20049) — A controlled repository-pair study of coding-agent task completion, token consumption and file revisits.
- [Human judgment doesn't leave the software factory. It relocates.](https://addyosmani.com/blog/human-judgment-doesnt-leave-the-software/) — Osmani's practical account of placing human judgment around automated software work, verification and release decisions.

## Slides

### The future of engineering

Addy Osmani says engineers will choose what is worth doing and own the evidence, understanding and verdict for work increasingly automated by agents, including decisions to ship or block it.

[0:34](https://www.youtube.com/watch?v=n97BCfyFIvw&t=34s) [Engineers choose what is worth doing and own the evidence, understanding, and verdict for work increasingly automated by agents.](https://assets.ai.engineer/sites/aiecode2025/sha256/f441c01804265732c47698528d4faad9b942158c95eec302f847fd732574a460.webp)

THE FUTURE OF ENGINEERING

The engineer of the future will choose what is worth doing, then own the evidence, understanding and verdict for work increasingly automated by agents.

@addyosmani

### The engineer as judge

A judge at a coding workstation illustrates the engineer’s responsibility for production decisions: whether to ship, block, redirect, or accept the risk of agent-generated work.

[1:07](https://www.youtube.com/watch?v=n97BCfyFIvw&t=67s) [A person dressed as a judge holds a gavel at a workstation surrounded by coding screens.](https://assets.ai.engineer/sites/aiecode2025/sha256/5d4b5187c26516a41a8cdac44bae4a0084a6b1e770f7ee4d722471303e3b4b11.webp)

COURT OF REDUNDANT CODE

Judge Bugs

CODE IS LIFE

COURT OF REDUNDANT CODE

Code on screens: [illegible]

### Quality, verdict, and answerability

Quality checks produce evidence for an accountable human verdict: ship, block, redirect, or accept the risk. Answerability means being able to explain and stand behind that decision later.

[1:13](https://www.youtube.com/watch?v=n97BCfyFIvw&t=73s) [Definitions connect quality with evidence, verdict with an accountable decision, and answerability with explaining and standing behind that decision.](https://assets.ai.engineer/sites/aiecode2025/sha256/2c066c722fd6cc038360c13f3d30cfb78a427a3ebcef2d3e86065b33d86f43b2.webp)

Quality = the system of checks that produces evidence.

Verdict = the human/accountable decision made from that evidence.

Answerability = the ability to explain and stand behind the verdict later.

@addyosmani

### Five role archetypes

Boris Cherny describes five ways to contribute: prototype ideas, build products, clean up systems, grow products, and maintain mature systems. People can span roles across job functions.

[1:45](https://www.youtube.com/watch?v=n97BCfyFIvw&t=105s) [A post describes prototypers, builders, sweepers, growers, and maintainers, noting that people can span roles and job functions.](https://assets.ai.engineer/sites/aiecode2025/sha256/a355f7af88193726747ac222c2e96e942c78d825bda4774ce1925bc02d9d9653.webp)

Boris Cherny
@bcherny

As engineering, product, design, DS, etc. melt into a new kind of role, I was reflecting on what roles might look like in the future. For example, when I look at the Claude Code team I see what I think is five archetypes:

1. Prototyper: comes up with brand new ideas; churns out many ideas, most of which don't ship
2. Builder: quickly turns a prototype/idea into production-grade product/infra
3. Sweeper: cleans up the UI, simplifies the code and system, unships, optimizes performance
4. Grower: takes a product that has been built and iterates on it to improve Product-Market Fit
5. Maintainer: owns a mature system to make it secure, reliable, fast, and efficient as it scales

Many people span across 2 roles, and sometimes 3 roles. I also notice that these roles are not really tied to job function -- eg. across Anthropic, some designers match category 1, some 2, some 3; same for engineers, PM, DS.

Interface text:
@addyosmani

### Roles organized around ownership

Osmani describes five engineering modes and argues that, as agents help with each, people must decide which mode the product needs, set the quality bar, and own the result.

[2:06](https://www.youtube.com/watch?v=n97BCfyFIvw&t=126s) [Roles are described as shifting toward ownership across prototyping, building, sweeping, growing, and maintaining.](https://assets.ai.engineer/sites/aiecode2025/sha256/1acac31247ef79a53a5c50129bcf9ecc8c5919e21d977fc23f2d72af6ad2233e.webp)

THE FUTURE OF CAREERS

Roles are unbundling from craft and rebundling around ownership.

Prototype. Build. Sweep. Grow. Maintain.

The title matters less than the part of the system you can own.

@addyosmani

### Harness engineering

A harness surrounds the model with context, control, observation, actions, persistence and hooks. The diagram connects failures and hooks to feedback and new rules.

[2:31](https://www.youtube.com/watch?v=n97BCfyFIvw&t=151s) [A model sits within a harness of context, control, observation, actions, persistence, and hooks, with a feedback path from failure to new rules.](https://assets.ai.engineer/sites/aiecode2025/sha256/ab96d6d678ceff219fac3c06c343f66c7f1525a2947f0a97d8071659764b6660.webp)

HARNESS ENGINEERING
THE AGENT IS THE SYSTEM AROUND THE MODEL
The scaffolding that turns a model into an agent.

agent = model + harness
harness: prompts, tools, state, constraints, feedback loops

CONTEXT
rules, memory

CONTROL
plans, routing

OBSERVE
tests, logs

MODEL
reasons / decides
one chip on the board

ACTION
tools, MCPs

PERSIST
files, git

HOOKS
block, retry

FAILURE
agent slipped

RATCHET
new rule

Source: addyosmani.com/blog/agent-harness-engineering

### Loop Engineering

A recurring loop automates work, sends agents into worktrees, verifies results and decides what happens next. State and learning carry information forward, while a verdict owns the outer loop.

[2:54](https://www.youtube.com/watch?v=n97BCfyFIvw&t=174s) [Diagram of a recursive engineering loop connecting automation, action, verification, isolation, decisions, state, learning, and human verdict.](https://assets.ai.engineer/sites/aiecode2025/sha256/f25e44747bc3bccb3e53006859254436f193a2e64cc90954c832f47b15457e81.webp)

FROM PROMPTING AGENTS TO DESIGNING THE SYSTEM THAT PROMPTS THEM

LOOP ENGINEERING
Design the loop, not the prompt.

loop = goal + cadence + isolated work + verification + state

VERDICT
owns outer loop

AUTOMATE
cadence finds work

STATE
memory lives outside

DECIDE
ship, block, queue

RECURSIVE GOAL
iterate until done

ACT
agents in worktrees

ISOLATION
parallel, no chaos

VERIFY
maker != checker

LEARNING
tomorrow reads today

Loops change the work. They do not delete the engineer.

Source: addyosmani.com/blog/loop-engineering

### Agentic Software Factory

Product intent, incidents and user feedback feed an agent loop that generates and verifies work. The loop produces evidence for a human verdict: ship, block or redirect.

[3:09](https://www.youtube.com/watch?v=n97BCfyFIvw&t=189s) [Diagram showing product intent, incidents, and feedback entering an agent loop that produces evidence for a human verdict.](https://assets.ai.engineer/sites/aiecode2025/sha256/f0efa383f6900a3e927e9b0efa86376d5affebf98433ce9d3b759d2f87744eae.webp)

THE SOFTWARE FACTORY, WITH THE LIGHTS ON
AGENTIC SOFTWARE FACTORY

product intent
incidents
user feedback
stuff worth doing

agent inner loop
guide / context
generate
verify / solve
sandbox, traces, tests

evidence
tests
diff summary
risk notes

human verdict
ship / block / redirect

monitor
users
prod

lights off fails here

The win is not removing people from the loop.
The win is moving human judgment to the highest leverage checkpoint.

### AI Code Share Is No Longer Marginal

The slide puts AI-generated or significantly assisted code at 42% of committed code now, rising to an estimated 65% in 2027. Osmani says its growing role makes answerability an engineering requirement.

[3:33](https://www.youtube.com/watch?v=n97BCfyFIvw&t=213s) [Line chart shows AI-generated or assisted code rising from 6% in 2023 to 42% now, with estimates of 55% in 2026 and 65% in 2027.](https://assets.ai.engineer/sites/aiecode2025/sha256/0ebd120d14b9776147820493f2a503ee8420bb1d22d0782c6d223c2f5d4bf48d.webp)

THE OUTPUT CURVE

AI code share is no longer marginal

Timeline: 2023 — 6%; 2024 — 19%; now — 42%; 2026 est. — 55%; 2027 est. — 65%

42%
of committed code is already AI-generated or significantly assisted

The factory is no longer experimental. It is entering the commit history.

Source: Sonar State of Code Developer Survey report 2026

### Clean Code Is Cheaper for Agents to Read

In a Sonar study, clean and messy repositories had roughly the same pass rates, but clean code used 7–8% fewer tokens and prompted 34% fewer file revisits.

[3:55](https://www.youtube.com/watch?v=n97BCfyFIvw&t=235s) [Slide reports 7–8% fewer tokens and 34% fewer file revisits for clean code, with the same pass rate.](https://assets.ai.engineer/sites/aiecode2025/sha256/bfe8c8564cbff8dcd2a38aae2f24695f4310454ae92329e17945a215ae57ae44.webp)

Clean code is cheaper for agents to read.

7-8% fewer tokens. 34% fewer file revisits. Same pass rate.

@addyosmani

### Reviewers Are Already Overloaded

Sonar’s survey reports that 96% do not fully trust AI-generated code, while 48% always verify it before committing. Another 38% say reviewing AI code takes longer than reviewing human code.

[4:23](https://www.youtube.com/watch?v=n97BCfyFIvw&t=263s) [Bar chart reports that 96% do not fully trust AI-generated code, 48% always verify it before committing, and 38% say reviewing it takes longer than human code.](https://assets.ai.engineer/sites/aiecode2025/sha256/1034f55078a0f30a8b9d8b474546e2e8ee220920c4b833eaea77ca5793379b1d.webp)

TRUST WITHOUT CAPACITY

Reviewers are already overloaded

Do not fully trust AI-generated code — 96%
Always verify AI code before committing — 48%
Say reviewing AI code takes longer than human code — 38%

2x
trust gap: skepticism is high, but verification is not keeping up

The risk is not that engineers distrust AI. It is that they distrust it and still ship faster than they verify.

Source: Sonar State of Code Developer Survey report 2026

### Generation Moved Faster Than Control

GitLab research reports that 85% see review and validation as a bottleneck, while 80% adopted AI faster than policy. Osmani connects the gap to questions about model involvement, constraints, evidence, and ownership.

[5:02](https://www.youtube.com/watch?v=n97BCfyFIvw&t=302s) [Bar chart presents governance challenges for AI-generated code, including review bottlenecks, technical debt, and adoption outpacing policy.](https://assets.ai.engineer/sites/aiecode2025/sha256/720ca233d9f1bd6269cd808bebf160a44ef89224e7b1422d3c1493309ea1e5bd.webp)

THE GOVERNANCE GAP

Generation moved faster than control

Review/validation is now the bottleneck — 85%
Governance after creation is the challenge — 84%
AI code risks new technical debt — 82%
Adopted AI faster than policy — 80%
Cannot reliably distinguish AI vs human code — 43%

92% report some governance challenge with AI-generated code

This is the argument for the HumanVerdict: provenance, intent, and ownership need a first-class interface.

Source: GitLab AI accountability research, June 2026

### What are you still for?

As agents ship more than people can review, Osmani asks where humans still add value. He argues that judgment backed by evidence becomes scarce when generation outpaces comprehension.

[5:31](https://www.youtube.com/watch?v=n97BCfyFIvw&t=331s) [Slide asks what people are still for when agents can ship more than they can review.](https://assets.ai.engineer/sites/aiecode2025/sha256/9e199b28953e0821255bf458b854ea527a2f412f7a8a0a712bf680cede7901b9.webp)

The agent can ship more than you can review.

So what are you still for?

@addyosmani

### Automating computers

A drinking bird faces a computer displaying Claude Code, a playful vision of automation. Osmani rejects it as inevitable: when generation outpaces comprehension, judgment backed by evidence becomes scarce.

[5:51](https://www.youtube.com/watch?v=n97BCfyFIvw&t=351s) [A drinking bird sits at a vintage computer displaying Claude Code and a terminal icon.](https://assets.ai.engineer/sites/aiecode2025/sha256/242e622dd3b08c123e84779a206423538e534e889a5e8e11ada93ec465c04c14.webp)

CLAUDE
CODE
+

### Alpha is the gap

Osmani defines alpha as the gap between your capabilities and current models, and decay as how quickly models close that gap.

[6:14](https://www.youtube.com/watch?v=n97BCfyFIvw&t=374s) [Alpha is the gap between human ability and current models; decay is how fast models catch up.](https://assets.ai.engineer/sites/aiecode2025/sha256/ee8042a699b9c47b6ed304148c5fa674fc9f895e0f120c828c63eea1b313ddf4.webp)

Alpha is the gap.

Alpha:
what makes you meaningfully better than what current models can do.

Decay:
how fast the models catch up.

@addyosmani

### Paul Graham on taste

Graham predicts that choosing what to make will matter more as AI makes creation easier. Osmani agrees, but cautions that taste can become a label for work we have yet to explain.

[6:42](https://www.youtube.com/watch?v=n97BCfyFIvw&t=402s) [Paul Graham post predicts that taste and choosing what to make will become more important in the AI age.](https://assets.ai.engineer/sites/aiecode2025/sha256/1d0b74c5452f7f3b87bfbd6ae77c379396c976b58d9184fcc4d7a31fdf6968fc.webp)

Paul Graham
@paulg

Prediction: In the AI age, taste will become even more important. When anyone can make anything, the big differentiator is what you choose to make.

paulgraham.com/taste.html

Interface text:
1:31 AM · Feb 14, 2026 · 2.1M Views
860 · 2.2K · 13K · 7.2K
@addyosmani

### Defining taste

Mitchell Hashimoto defines taste as consistently making high-quality qualitative judgments without an objective metric. Osmani argues that critique and examples can improve that judgment over time.

[7:04](https://www.youtube.com/watch?v=n97BCfyFIvw&t=424s) [Mitchell Hashimoto defines taste as consistent qualitative judgment without an objective metric, and says its results are easy to copy. The final paragraph is cut off.](https://assets.ai.engineer/sites/aiecode2025/sha256/1fbede081bd55bcb52dd29eb996fc1e3dbfccd7e9a66a81354712df81992170f.webp)

Defining Taste

Mitchell Hashimoto
@mitchellh · Jun 26

“Taste” is the ability to consistently make high-quality qualitative judgments where no objective metric exists. It’s the creation of something that feels right intuitively, with no real justifiable way to measure that. But when you do it, people feel it.

A person with “good taste” is someone who can do this repeatedly, consistently. The funny thing about taste is that it’s hard to create, but its result is very easy to copy. Once someone makes a tasteful decision, others can imitate it almost immediately.

This is usually an argument against the existence of taste: “look how easy I

Interface text:
130  525  3.8K  706K
@addyosmani

### Taste before the metric

Osmani argues that when generating options gets cheaper, taste helps decide which deserves to exist. Better judgment also leaves examples for teams and systems to learn from.

[7:42](https://www.youtube.com/watch?v=n97BCfyFIvw&t=462s) [Taste is judgment before a metric exists: hard to create, easy to copy, and valuable because it influences what others copy.](https://assets.ai.engineer/sites/aiecode2025/sha256/3364f638cdc1eb1b1ee90f275aed18b8c399f79cbc64b04a3555eb89360612ac.webp)

Taste is the judgment before the metric exists.

Hard to create. Easy to copy.

Valuable because it decides what everyone copies next.

@addyosmani

### The capability decay test

Osmani sees speed and recall decaying as verification moves into automated checks. He expects taste to decay more slowly, while judgment follows a slope rather than a wall.

[8:15](https://www.youtube.com/watch?v=n97BCfyFIvw&t=495s) [Speed and recall are described as gone, verification as automating, and taste and judgment as slower to decay.](https://assets.ai.engineer/sites/aiecode2025/sha256/17b54ef1900ec28c383ebc1a56be097f700bee28b94d97d327d692255d6cbd42.webp)

THE TEST: IS IT A CAPABILITY? THEN IT DECAYS

Speed gone. 600 lines while you find coffee
Recall gone. it's a context window now
Verification automating. and we were the weak link

Eventually? Maybe?
Taste alpha. resets every release. Will take longer to decay.
Judgment a slope rather than a wall

@addyosmani

### What can a human be answerable for?

As agents gain capabilities, Osmani shifts the question to human answerability: decisions require context, risk acceptance, and responsibility after work ships.

[8:47](https://www.youtube.com/watch?v=n97BCfyFIvw&t=527s) [Slide asks what only a human can be answerable for, rather than what AI cannot do.](https://assets.ai.engineer/sites/aiecode2025/sha256/0b2f89095dfeec441b4af85ca2232ad310dde9d2e1f63a83fce1ae2e9729a0a1.webp)

ONE QUESTION: WHAT CAN THE AGENT DO?

Stop asking what AI can't do.

Ask what only a human can be answerable for.

### Developers and engineers

Osmani describes engineers as people who reason about systems, defend trade-offs, manage risk, and take responsibility when things break.

[9:15](https://www.youtube.com/watch?v=n97BCfyFIvw&t=555s) [Slide distinguishes developers from engineers and asks what engineers should avoid to stay effective and accountable.](https://assets.ai.engineer/sites/aiecode2025/sha256/1e883e488ca25277f0fd3850ded8873fb65a4614db96777455f6e619fc85cc0e.webp)

Everyone is a developer now. That doesn't make them an engineer.

What should engineers avoid to stay effective and accountable?

@addyosmani

### Cognitive debt

Cognitive debt erodes problem-solving understanding; in code, teams can lose the ability to explain what they ship. The slide cites an Anthropic study of 52 engineers: 50% comprehension when learning through AI-generated code, versus 67%.

[9:53](https://www.youtube.com/watch?v=n97BCfyFIvw&t=593s) [Cognitive debt is defined as erosion of understanding and memory for solving problems; the slide reports a comprehension comparison of 50% versus 67%.](https://assets.ai.engineer/sites/aiecode2025/sha256/8d032387f5c2923e790ede00394e9afa48ad3545861777044ff40f72276d5f5f.webp)

Cognitive debt.

The erosion of your understanding and memory around how to solve problems.

17% lower comprehension when you learn through AI-generated code, 50% vs 67%. Anthropic, 52 engineers.

@addyosmani

### Accountability scales the factory

As agents work faster and in parallel, people must explain intent, inspect evidence, accept risk, and improve the system when a decision is wrong.

[12:48](https://www.youtube.com/watch?v=n97BCfyFIvw&t=768s) [Accountability is not what remains after agents get good; it is what lets the rest scale.](https://assets.ai.engineer/sites/aiecode2025/sha256/c700cfd649e0a4287da8103b00745a3984b64d9fa21e12473b2896bff0a04e25.webp)

ACCOUNTABILITY SCALES THE FACTORY

Accountability is not what remains after agents get good.

It is what lets the rest scale.

### The half life of an edge and a signature

The chart shows speed, verification and taste declining across model releases while accountability stays level. Osmani calls the signature the person, team or institution standing behind what ships.

[13:13](https://www.youtube.com/watch?v=n97BCfyFIvw&t=793s) [A chart shows accountability remaining level while curves for speed, verification and taste decline across model releases.](https://assets.ai.engineer/sites/aiecode2025/sha256/d2d3a7fbd1c0aba55c7257eb7caa720ecd35e2843e6468333da2a1de8ff57741.webp)

WHAT DECAYS. WHAT DOESN'T.

The half life of an edge is a release.
The half life of a signature is a career.

Y-axis: durability
X-axis: model releases

accountability
speed
verification
taste
[illegible]ion

## Full transcript

[0:00](https://www.youtube.com/watch?v=n97BCfyFIvw&t=0s) [on-hold jingle] Howdy, folks.

[0:23](https://www.youtube.com/watch?v=n97BCfyFIvw&t=23s) So good afternoon or good whatever time it is when you're watching this on YouTube. I'm really excited to be here. And, um, today I want to talk to you about really, uh, what it takes to keep the human in the loop where engineering is concerned.

[0:40](https://www.youtube.com/watch?v=n97BCfyFIvw&t=40s) I really wanna start with the human side before we talk about the architecture here. I think that the engineer of the future is gonna be really defined by the person who is able to choose what is worth doing.

[0:54](https://www.youtube.com/watch?v=n97BCfyFIvw&t=54s) They're gonna own the evidence, they're gonna own the understanding, as well as the verdict around increasingly automated work that's being done by agents. Now, when I use the term verdict, I don't mean that we're suddenly all gonna be Judge Judy.

[1:10](https://www.youtube.com/watch?v=n97BCfyFIvw&t=70s) We're not. But what I mean really is something just a little bit different. I mean, we're gonna be accountable for the production decisions. Does something ship? Do we block it?

[1:22](https://www.youtube.com/watch?v=n97BCfyFIvw&t=82s) Do we redirect it or accept the risk? Quality is something that we all talk about a lot, but quality produces evidence. A verdict assigns responsibility, and answerability is really what lets us stand behind a verdict.

[1:39](https://www.youtube.com/watch?v=n97BCfyFIvw&t=99s) And this, of course, is not the only way that our industry is starting to think about our roles evolving.

[1:46](https://www.youtube.com/watch?v=n97BCfyFIvw&t=106s) Boris Cherny recently put some useful language around what many teams are starting to feel. The old craft boundaries are getting blurry, and roles are rebundling around the work itself.

[1:58](https://www.youtube.com/watch?v=n97BCfyFIvw&t=118s) And the important question here becomes a lot less about what is your title and more what part of the system can you own.

[2:06](https://www.youtube.com/watch?v=n97BCfyFIvw&t=126s) Now, I like this taxonomy quite a lot. Um, it's optimistic without being overly vague, so things like prototype, build, sweep, grow, and maintain. And these are real engineering modes.

[2:20](https://www.youtube.com/watch?v=n97BCfyFIvw&t=140s) Agents are gonna help with all of them, but the scarce thing is not merely doing the task. It's gonna be knowing which mode your product needs and what quality bar applies, and who owns the result at the end of the day.

[2:33](https://www.youtube.com/watch?v=n97BCfyFIvw&t=153s) Now, we've been talking about harnesses and loop engineering and software factories over the last couple of days. We can talk why this shift is happening. We've moved past the model as the whole story, right?

[2:44](https://www.youtube.com/watch?v=n97BCfyFIvw&t=164s) With harness engineering, the coding agent is the model plus the harness around it, right? Your context, your tools, your file system, Git. And the harness is what turns intelligence into something that you can delegate to.

[2:56](https://www.youtube.com/watch?v=n97BCfyFIvw&t=176s) The next move was loop engineering, where we weren't just prompting one run anymore. We were designing systems that kept prompting, checking, and remembering, and deciding what happened next. And that's really when agents started to feel like infrastructure.

[3:10](https://www.youtube.com/watch?v=n97BCfyFIvw&t=190s) And once you start putting all of those things together, you get that software factory. Dex covered this well in his talk. But you have agents that are running inside that inner loop and evidence that comes out.

[3:22](https://www.youtube.com/watch?v=n97BCfyFIvw&t=202s) Humans still end up making the production decisions in this loop, and the win really isn't moving us from it. The win is moving human judgments to the highest leverage checkpoint, I think.

[3:35](https://www.youtube.com/watch?v=n97BCfyFIvw&t=215s) And this is why it starts to matter now. AI-generated and AI-assisted code is becoming normal code for a lot of us. One of Sonar's twenty twenty-six surveys said that AI-assisted code is no longer marginal.

[3:47](https://www.youtube.com/watch?v=n97BCfyFIvw&t=227s) It's increasingly having a large role in our code bases. And once that happens, answerability stops being this philosophical word. It becomes an engineering requirement. And there's a quality point here as well, right?

[3:59](https://www.youtube.com/watch?v=n97BCfyFIvw&t=239s) Like, we used to care about clean code, code that people could read. But cleaner code is actually not just gonna help the next human and the next person on your teams.

[4:09](https://www.youtube.com/watch?v=n97BCfyFIvw&t=249s) It actually helps the next agent. Another one of Sonar's research, uh, studies found that clean and messy repos had roughly the same pass rates, but clean code actually used fewer tokens and caused fewer revisits.

[4:21](https://www.youtube.com/watch?v=n97BCfyFIvw&t=261s) So there's a lot of benefit to maintainability that can fuel efficiency for your factories. Now, making generation cheaper does not automatically make review cheaper, right? I think a lot of us are facing this moment, and we know that engineers are not naive.

[4:36](https://www.youtube.com/watch?v=n97BCfyFIvw&t=276s) The Sonar numbers say that almost everybody is skeptical of AI code. Now, I love working in my software factory. I love building my engineering loops. But the problem is still capacity.

[4:48](https://www.youtube.com/watch?v=n97BCfyFIvw&t=288s) If ninety-six percent of people don't fully trust that code, but only about half always verify before committing, we have this danger that we've got distrust without bandwidth. And so safety comes from making verification cheaper, clearer, and harder for people to skip.

[5:04](https://www.youtube.com/watch?v=n97BCfyFIvw&t=304s) And if you zoom out from the individual reviewer to the organization, review and validation start becoming a bottleneck when governance isn't able to catch up and adoption is already moving way faster than any company can go and set their policies.

[5:18](https://www.youtube.com/watch?v=n97BCfyFIvw&t=318s) And this means that we have some hard questions we have to deal with, like did a model actually touch this file? And the hard questions are also like what constraints guided that work?

[5:27](https://www.youtube.com/watch?v=n97BCfyFIvw&t=327s) What evidence was produced? What risk was accepted, and who owned the result? Now, the agent can ship more than any of us can review, right? So what are we still good for?

[5:40](https://www.youtube.com/watch?v=n97BCfyFIvw&t=340s) I think it's a question that's on a lot of our minds, right? And, you know, if Homer Simpson's experience automating computers can teach us anything, maybe this is our future.

[5:51](https://www.youtube.com/watch?v=n97BCfyFIvw&t=351s) I don't think it is, but it's one direction things could take. Now, let's try that again. If change is where humans enter the loop, if generation scales faster than comprehension, the scarce resource becomes judgment that's backed by evidence.

[6:06](https://www.youtube.com/watch?v=n97BCfyFIvw&t=366s) So the question is no longer how much can the agent do, but where does human judgment still create leverage? Now, I want to talk to you about two terms that I'm going to use for the career part of this talk, alpha and decay.

[6:22](https://www.youtube.com/watch?v=n97BCfyFIvw&t=382s) Alpha is the gap between what you can do today and what current models can do. That gap is a very real thing, and decay is the clock on that gap.

[6:34](https://www.youtube.com/watch?v=n97BCfyFIvw&t=394s) If the thing that makes you special is a capability, the frontier is eventually going to come for it, right? And there's a whole conversation around this. This is one of the reasons why taste keeps coming up.

[6:47](https://www.youtube.com/watch?v=n97BCfyFIvw&t=407s) Paul Graham had a point here that I think is very right. When anyone can make anything, choosing what to make becomes very important, and I buy that. But I also think that we have to be very careful because taste can become a magic word for whatever part of the work we don't want to explain just yet.

[7:06](https://www.youtube.com/watch?v=n97BCfyFIvw&t=426s) Mitchell Hashimoto gave us a more useful version of this definition. Taste is the ability to make high-quality, qualitative judgments where no objective metric exists yet. That matters because it puts taste before the benchmark and before the market has fully voted.

[7:22](https://www.youtube.com/watch?v=n97BCfyFIvw&t=442s) When you try out a model and you see the kind of UX and the kind of experiences that it builds, you can often tell when you think it has taste or lacks taste, or where there's a gap there that humans can fill.

[7:34](https://www.youtube.com/watch?v=n97BCfyFIvw&t=454s) Now, this is also only useful if we can turn some of this concept around taste into critique, examples, and better judgment over time. So yes, taste matters when production gets cheaper, and if anyone can generate ten options, the scarce skill is really knowing which option deserves to exist.

[7:54](https://www.youtube.com/watch?v=n97BCfyFIvw&t=474s) But taste is not some eternal moat. It's alpha as well. Now, the people with taste are still going to matter. I personally think they're still going to matter for a long time.

[8:06](https://www.youtube.com/watch?v=n97BCfyFIvw&t=486s) But the best version of that skill is not mystique. It's making better calls and leaving behind examples that your team and the system can learn from. Now, let's apply the decay test.

[8:19](https://www.youtube.com/watch?v=n97BCfyFIvw&t=499s) Well, we used to have speed. That decayed. We used to have recall. You know, harnesses have memory. Verification is moving into harnesses, evals, static checks, and model critique. Taste, I continue to think this is going to decay much more slowly, but it still resets as models learn from examples and preferences.

[8:38](https://www.youtube.com/watch?v=n97BCfyFIvw&t=518s) Even judgment, in some ways, is a slope rather than a wall. So the strategy is not to cling to any one capability. It's for us to keep moving our edges up a level.

[8:48](https://www.youtube.com/watch?v=n97BCfyFIvw&t=528s) So this is one of the reasons why what can the agent do is not the best strategic question anymore. The list of things that agents can't do just keeps shrinking.

[8:58](https://www.youtube.com/watch?v=n97BCfyFIvw&t=538s) The better question for us is really what can only a human be answerable for? Not because, you know, any of us are, are magical in any way, but because some decisions actually require ownership.

[9:10](https://www.youtube.com/watch?v=n97BCfyFIvw&t=550s) They require context, risk acceptance, and responsibility after that work ships. This is why the word engineer has to get just a little bit stricter. More people than ever can now make computers do things, and I think that's truly awesome.

[9:26](https://www.youtube.com/watch?v=n97BCfyFIvw&t=566s) The total addressable market for builders has never been larger, and that's so cool. But it's a huge expansion of the leverage. An engineer is not merely somebody who can code, you know, and, and get things to exist.

[9:39](https://www.youtube.com/watch?v=n97BCfyFIvw&t=579s) An engineer can reason about systems. They think about constraints. You defend trade-offs. You can manage risk, and you're the person that can be reached out to when things start to break.

[9:48](https://www.youtube.com/watch?v=n97BCfyFIvw&t=588s) So what are things that engineers should avoid if we want to stay effective ac- and accountable in this moment? Well, the first thing to avoid really is cognitive debt.

[9:59](https://www.youtube.com/watch?v=n97BCfyFIvw&t=599s) Now, cognitive debt is the erosion of your understanding and memory around how to solve problems. I think a lot of us start to feel this the more that we're using agents every single day.

[10:09](https://www.youtube.com/watch?v=n97BCfyFIvw&t=609s) I know that I feel this a lot, and it's because we're deferring more and more to AI to solve our problems. For code, it's the gap between how much code exists in your repo and how much any human on your team genuinely understands.

[10:23](https://www.youtube.com/watch?v=n97BCfyFIvw&t=623s) And this is why things like delegation depth end up mattering. You can have a build that passes, you know, your tests, a PR that you can merge, but your s- team can still end up losing its ability to actually explain the system that they are shipping to production.

[10:38](https://www.youtube.com/watch?v=n97BCfyFIvw&t=638s) Now, a very real pressure is almuch-- is also how much we delegate. So agents can now stay inside the system long enough for the human to lose the thread.

[10:47](https://www.youtube.com/watch?v=n97BCfyFIvw&t=647s) So a thirty-second run, right, can feel like an interaction, but an hour or a day scale task, so something long horizon, that's a work stream. And when tasks can end up l- you know, lasting that long, especially when you begin running many of them in parallel, review can't just be a glance at the end.

[11:04](https://www.youtube.com/watch?v=n97BCfyFIvw&t=664s) It has to become a whole control system. The second thing to avoid is cognitive surrender. Now, this is when you blindly accept AI's, um, responses. Like, delegation is important because delegation says, "Do the work, then show me enough evidence that I can judge it."

[11:22](https://www.youtube.com/watch?v=n97BCfyFIvw&t=682s) I still make a judgment in that situation. Surrender is really saying, "Hey, your answer is now my answer before I have formed any opinions myself." Now, uh, Wharton did a study that kind of offers us a warning light here.

[11:36](https://www.youtube.com/watch?v=n97BCfyFIvw&t=696s) When AI was wrong, seventy-three percent of people still s- thought that they, they, you know, they picked the wrong answer, and they felt more sure. So the failure mode is not using AI, but it's borrowed confidence.

[11:50](https://www.youtube.com/watch?v=n97BCfyFIvw&t=710s) The third thing to avoid is orchestration tax. Now, if you've been in the Bay Area, you will see people who, for better or worse, are still walking around with their laptops open or are talking to you about cloud agents.

[12:01](https://www.youtube.com/watch?v=n97BCfyFIvw&t=721s) And we're increasingly trying to run more and more and more in parallel or telling each other that we're shipping with hundreds of agents or thousands of agents. More AI agents running does not mean that there is more of you available.

[12:15](https://www.youtube.com/watch?v=n97BCfyFIvw&t=735s) Your cognitive bandwidth does not parallelize. So every loop that you create ends up causing more decisions to route, merge, verify, and integrate. And the fix is not necessarily fewer agents, but it's about designing your attention like a system.

[12:31](https://www.youtube.com/watch?v=n97BCfyFIvw&t=751s) Like where you enter, what you acquire, what you reuse. You just wanna be very intentional about it.

[12:38](https://www.youtube.com/watch?v=n97BCfyFIvw&t=758s) Now, accountability can be a scary word for a lot of people, and I wouldn't be surprised if it made you wanna go hide in the bushes and just tell your agent to deal with it.

[12:49](https://www.youtube.com/watch?v=n97BCfyFIvw&t=769s) But accountability is not what remains after agents get good. It's what lets the rest of the whole system scale. If agents can do more work, if they can do it faster, in parallel, better than what many of us could do, the scarce thing becomes the ability to explain intent, to inspect evidence, to accept risk, and improve the

[13:10](https://www.youtube.com/watch?v=n97BCfyFIvw&t=790s) system when the decision was wrong. Now, here is the career math. The half-life of an edge might be one model release. Speed, recall, verification, even taste all move as the frontier moves.

[13:26](https://www.youtube.com/watch?v=n97BCfyFIvw&t=806s) But the half-life of a signature, your credibility, your expertise, is much longer. And by signature, I really mean the name on the work, the person, the team, the institution, whoever stands behind what's actually shipped.

[13:41](https://www.youtube.com/watch?v=n97BCfyFIvw&t=821s) So skills can earn leverage. Accountability can turn leverage into trust. And this is one of the lines that I wanna draw pretty clearly. Agents can choose, they can route, they can merge, they can escalate, they can operate inside policy.

[13:54](https://www.youtube.com/watch?v=n97BCfyFIvw&t=834s) And in many systems, you know, they can, they should. But execution and responsibility are very different things. The agent can follow your runbook, but it can't inherit the consequences.

[14:04](https://www.youtube.com/watch?v=n97BCfyFIvw&t=844s) When something fails, the question is: Who understood the policy? Who accepted the risk, and who owns the blast radius? High agency is something that a lot of us talk about these days as being, like, this thing that we're looking for when we're hiring.

[14:18](https://www.youtube.com/watch?v=n97BCfyFIvw&t=858s) High agency is actively taking ownership of your outcomes. So knowing when to delegate, when to inspect, when to stop, and when to put your name on the result. High agency in this world is not, "I personally do everything."

[14:31](https://www.youtube.com/watch?v=n97BCfyFIvw&t=871s) You know, that version doesn't really scale. It's not just hustle theater, but it's ownership with judgment attached. This agency ladder tries to make that a little bit more concrete.

[14:43](https://www.youtube.com/watch?v=n97BCfyFIvw&t=883s) At the bottom, you've got someone that flags a problem and leaves it for the system. Higher up, they execute, diagnose, propose, recommend, and resolve. And the rare top movement is discernment.

[14:55](https://www.youtube.com/watch?v=n97BCfyFIvw&t=895s) You know, maybe you find a problem and you decide whether or not it's worth investing in. Maybe it's not, and maybe you move on. But when agents make more paths possible, agency is not chasing every single path.

[15:07](https://www.youtube.com/watch?v=n97BCfyFIvw&t=907s) It's really just deciding which paths deserve your ownership and attention. So translate that into an operating model. Agents can run much more of the inner execution loop. They can investigate, implement, test, and report.

[15:21](https://www.youtube.com/watch?v=n97BCfyFIvw&t=921s) I think that there's leverage in that. But that outer loop is still engineering. So deciding, verifying, approving, owning. That inner loop is capability. The outer loop is agency.

[15:33](https://www.youtube.com/watch?v=n97BCfyFIvw&t=933s) And this is a boundary that I really care about. Your agent returns evidence. It returns diffs, tests, logs, rationale, traces, trajectories, screenshots, whatever the work itself requires. But then the engineering really begins.

[15:48](https://www.youtube.com/watch?v=n97BCfyFIvw&t=948s) We decide whether the work was worth doing. We verify whether the evidence is enough, and we approve or redirect or own what reaches production. It doesn't matter if you're someone that's just working with a small number of agents or whether you're working with thousands of agents.

[16:03](https://www.youtube.com/watch?v=n97BCfyFIvw&t=963s) I still very much think that these ideas apply. So the boundary is not human looks at AI output. The boundary is evidence and responsibility.

[16:13](https://www.youtube.com/watch?v=n97BCfyFIvw&t=973s) So here's an operational rule. Explain it or don't ship it. And it's not because humans have to type every line or read every line, but because someone has to understand the work well enough to defend it.

[16:25](https://www.youtube.com/watch?v=n97BCfyFIvw&t=985s) If you've ever worked in a large code base or an enterprise code base, some code bases have this concept of an owner's file or cer-certain subdirectories where there are people who are on the hook for that part of the system.

[16:36](https://www.youtube.com/watch?v=n97BCfyFIvw&t=996s) You can think about this in a very similar way. Who's accountable for that part of your architecture and your code base? Your model might write the code, and the question is really still whether you can explain those changes that the agent is shipping, whether you've got the evidence whether you understand the risks.

[16:52](https://www.youtube.com/watch?v=n97BCfyFIvw&t=1012s) Now, this is one of the things I want you to remember near the end. Automation moves the floor for all of us. Engineering continues to move up a level, and our new work might be loop design, evidence design, and brownfield stewardship.

[17:07](https://www.youtube.com/watch?v=n97BCfyFIvw&t=1027s) But fewer keystrokes doesn't mean less engineering over the next few years. It means that there is more surface area that needs taste, verification, ownership, and ultimately care.

[17:20](https://www.youtube.com/watch?v=n97BCfyFIvw&t=1040s) I don't think I've ever been more excited about the future of this field. Every time that we have made it easier to write software, we've predicted that the world would need less of it, and in fact, the opposite happened.

[17:33](https://www.youtube.com/watch?v=n97BCfyFIvw&t=1053s) Higher level languages happened, frameworks, cloud, low code. The pattern always went the other way. And when you lower the cost, latent demand ends up appearing. Those ideas that people didn't think were feasible to build and get out there are suddenly unlocked.

[17:48](https://www.youtube.com/watch?v=n97BCfyFIvw&t=1068s) And agents are gonna do the same thing for a lot of people. It's not gonna remove engineering work. It's gonna move the bottleneck from, "Can we build this?" to, "Should this exist, and can we answer for it?"

[17:59](https://www.youtube.com/watch?v=n97BCfyFIvw&t=1079s) So build the factories, keep the lights on, own the verdict. I hope this was useful. Thank you. [audience applauding] [upbeat music]
