Six shifts after the diff

Six layers replace the diff

Over three days in November 2026—33 recorded talks, 101,668 transcribed words, and 191 structured claims—one shift dwarfed every model announcement: code generation is no longer the scarce skill, and the pull-request diff is no longer the primary unit of software trust.

Instead, engineering value snapped into six reinforcing layers. Teams anchor safety at the bottom with owned verification loops, scale continuous maintenance through brownfield factories, strip away brittle prompt harnesses in favor of fast sandboxes, offload inline classification to sub-second System One models, replace sprawling connectors with modeled context, and spend human judgment at the top on taste and ambition.

Own the verification loop

The deepest consensus of the summit: trust in agent-generated systems comes from owning the verification loop—deterministic checks, stakes-scaled credentials, replayable execution traces, hardened sandboxes, and continuous failure diagnosis—rather than reading diffs line by line.

“Now we can build things in minutes or hours. But the review and testing still takes hours or days if we're doing it in the old way. So we bring in agentic code review, agentic testing.”Dexter Horthy · 12-Factor-Factories: Design Patterns for Agentic Coding · 00:04:20

“So instead of thinking about owning the code. Own the guardrails. Own the rules.”Ankit Jain · One team's path to trusting AI generated code · 00:17:18

Open Theme 01 Deep Dive: Own the verification loop (19 talks) →

Brownfield & demand factories

Because coding tokens make tiny teams perform like large organizations whenever live runtime feedback exists, agentic factories flourish on existing brownfield codebases—bounded by real token economics, durable multi-hour runtimes, and companion demand loops that grow the moat.

“But in the end, what matters is actually not the code.”Fabian Hedin · What it takes to set intelligence free · 00:02:04

“We have to figure out how to build a demand factory. Because our brownfield factory can't build the moat. Right. All it can do is keep our existing promises running well.”Justin McCarthy · Brownfield Factories · 00:13:17

Open Theme 02 Deep Dive: Brownfield & demand factories (16 talks) →

Delete the harness

Every model release absorbs scaffolding the previous generation required. Speakers repeatedly advised deleting over-engineered orchestration wrappers and investing instead in millisecond sandboxes, fast tool execution, semantic tool surfaces, and one shared company agent with public traces.

“General methods that leverage computations are ultimately the most effective by a large margin”Philipp Schmid · I deleted 90% of my harness (And It Got Better) · 00:00:13

“how much of the harness do I really need to achieve the Same task, and what is overhead to the model”Philipp Schmid · I deleted 90% of my harness (And It Got Better) · 00:03:20

Open Theme 03 Deep Dive: Delete the harness (15 talks) →

System One decision models

Uncontested across four talks, sub-second calibrated decision models move AI out of heavyweight conversational chat loops and turn model inference into a fast, deterministic fourth logic gate embedded straight inside DuckDB queries, UI keystrokes, and live web-grounded pipelines.

“We don't have to send every request to an LLM.”Michelle Chen · cloudflare is a neolab · 00:07:50

“I often call it you get Einstein ninety five percent of the time, but Mr Bean five.”Diogo Almeida · I love you so jevving much · 00:08:57

Open Theme 04 Deep Dive: System One decision models (4 talks) →

Modeled context over connectors

Wiring agents directly to dozens of uncurated SaaS connectors multiplies latency, broken permissions, and conflicting facts. Enterprise builders pushed context upstream into governed warehouse data models, unified permission-filtered search indexes, and actively pruned agent memory.

“The company context is the key here.”Utkarsh Shrivastava · Building a Shared AI Assistant: The Platform Challenges Beyond MCP · 00:02:11

“Intent is why are we making whatever change.”Ankit Jain · One team's path to trusting AI generated code · 00:08:38

Open Theme 05 Deep Dive: Modeled context over connectors (13 talks) →

Judgment when code is free

Zero-cost implementation shifts engineering value away from typing syntax toward human judgment, taste, ambition, and deliberate attention budgets—forcing teams to triage expected pain and guard engineers from high-speed decision fatigue.

“AI cannot replace human judgment. It can only amplify our judgment, or maybe perhaps our lack of judgment in certain cases. And the slop is asymmetric. The cost of producing a thousand line PR or a ten page doc is approaching zero. But the cost of reviewing it is still barely constant.”Dexter Horthy · 12-Factor-Factories: Design Patterns for Agentic Coding · 00:14:43

“and I think it's the theme of this conference: is to be more ambitious now that we have all of these new tools.”Simon Willison · 2026 in LLMs · 00:01:58

Open Theme 06 Deep Dive: Judgment when code is free (13 talks) →

Six fault lines where speakers disagreed

Beneath the shared six-layer blueprint, builders divided sharply on six practical bets:

1. Warehouse modeling vs. unified search vs. ruthless pruning. Data teams such as Claire Carroll argued agents should read governed analytics tables (“The exact same skills that made them good at delivering analytics are going to make them good.”, 00:26:44), Aamir Shakir advocated one pre-indexed search layer, and Steve Yegge told teams drowning in bloated rule files:

“So you just gotta go in there and just aggressively slash the crap out of it.”Steve Yegge · Software Factories: Escape from Trash Mountain · 00:10:42

2. Single-agent threads vs. supervised swarms. While Karan Vaidya and Steve Yegge scaled multi-agent fleets across code and knowledge work, Fabian Hedin argued concurrent agent edits remain fundamentally hard to reconcile:

“So unlike it, we cannot merge agent trajectories”Fabian Hedin · What it takes to set intelligence free · 00:06:56

3. Deleting the harness vs. encoding rules in code. Philipp Schmid stripped orchestration down to raw bash, whereas Lauren Tan insisted on codifying team lessons directly into deterministic codebase checks: “Instead of adding another line to your rules or your agent's dot md, because it's far more reproducible, it's in code.” (00:02:55).

4. Inline System One calls vs. general agent loops. Diogo Almeida bypassed multi-step embeddings and agent retrieval entirely (“But with Jeff, we basically take out all the embedding steps.”, 00:08:03), whereas retrieval platforms kept general tool-calling loops for ambiguous queries.

5. Continuous brownfield cadence vs. 48-hour weekend drops. Justin McCarthy grounded factories in steady maintenance (“So you've got an existing codestate. You've got an existing set of promises. Just make it continuous. Make it loop and make it keep those promises.”, 00:06:30), while Michelle Chen showed Cloudflare shipping a custom trained model inside one 48-hour weekend.

6. Hard pause gates vs. overfencing paralysis. Raz Berman Gold enforced explicit deterministic stops (“You can define pausing, deterministic stop, where the agent will stop.”, 00:04:32), while Steve Yegge warned teams can lock agents down so tightly that nothing ever ships.