Geoffrey Litt — design engineer at Notion, ex-Ink & Switch — opened the AI Engineer Design Engineering track with what he called a hot take: in 2026, it is still important for humans to understand how their code works. The framing sounds obvious until he lands the actual claim: agents are now writing 50,000-line PRs, and the practices that let a person stay a genuine participant in that project are not the practices that used to work. Reading code line-by-line no longer scales. Something else has to.

The bottleneck moved

Litt’s argument in one sentence: the job of a senior engineer is to answer “is this correct?” — and correctness has many shades (does it work, is it maintainable, does it fit the product, does it match intent). If you can’t answer that question, you’re not a participant in the project; you’re a rubber stamp. The scaling problem is that agents produce artifacts faster than a human can read them, so the old ritual of “read the diff top to bottom” is now the bottleneck, not the safeguard.

The hot take: understanding still matters

His frame for the rest of the talk: don’t argue about whether understanding matters — assume it does — and instead look for new practices that let you understand code you did not write, at a speed that keeps up with agents that don’t sleep.

Three techniques

Three techniques: explanations, intuition, shared spaces

He proposes three techniques he actively uses at Notion. None of them are novel individually; the interesting move is treating them as first-class engineering artifacts that agents produce alongside code.

1. Explanations

Have the agent write down what it did and why, in the same PR. Not the mechanical changelog — the reasoning trail. Litt walks through a video-editing project where the agent’s PR includes a prose section explaining the coordinate system, the Z-layer semantics, and which invariants it maintained. The explanation is for the human reviewer, and the reviewer’s job is to check the explanation against the code, not read every line.

Example explanation artifact from a video-editing project

Key nuance: the explanation must reference what you already know. A good agent-authored explanation isn’t a tutorial; it’s a delta against the reader’s existing mental model. That framing is what makes it fast to read.

2. Intuition

Building intuition — playgrounds and interactive artifacts

Explanations tell you the what; intuition gives you the feel. Litt’s version of intuition-building for AI-generated code is interactive artifacts — small playgrounds the agent builds alongside the feature. Sliders, live previews, “step through this transformation frame by frame.” He shows a timeline scrubber the agent produced so he could see, at any point, what state the video-editor was in.

His memorable framing: “make me essentially a video game where I do the port myself.” The intuition artifact is the game controller. You wiggle inputs, watch outputs, and internalize the shape of the code without reading it. The quiz — the moment where you realize you can’t answer a basic question — is the speed regulator. If the quiz breaks, you go back and read.

The ‘quiz’ as speed regulator

3. Shared spaces

The third technique is about collaboration boundaries. When multiple humans and agents are all working on the same codebase, you need shared spaces where the context is visible — not just PRs, but ambient docs, design sketches, and question threads that both agents and teammates read and write into.

Shared spaces: humans + agents in the same context

Litt’s example: he asks a product question in a shared space, an agent proposes a design, a teammate weighs in on the tradeoffs, and the resulting decision becomes part of the artifact the next agent reads. The point is not any particular tool; it’s the recognition that context is the substrate, and if agents and humans don’t share one, understanding fractures.

The Engelbart callback

Engelbart — augmenting human intellect

He closes on Doug Engelbart’s 1968 framing of “augmenting human intellect.” The meme version is that AI replaces the human. Litt’s read is different: we are putting ourselves more deeply in loops than we ever have before, and the point of these three practices — explanations, intuition, shared spaces — is to make those loops legible. Understanding isn’t a nostalgic virtue; it’s what makes the loop close.

Key takeaways

  1. The scarce resource shifted — from writing code to understanding code fast enough to keep up with agents.
  2. “Is this correct?” is still the senior engineer’s job. Correctness spans correctness, maintainability, intent-fit — none of which read-the-diff scales to at 50k lines.
  3. Explanations are artifacts, not annotations. Have the agent produce a reasoning trail keyed to what the reader already knows.
  4. Build intuition with interactive playgrounds. Sliders, timelines, scrubbers — small games that let you feel the code without reading it.
  5. Use quizzes as speed regulators. The moment you can’t answer a basic question is the moment to slow down and dig in.
  6. Shared spaces are the substrate. If agents and humans don’t share context, understanding fractures across the team.
  7. The Engelbart frame beats the replacement frame. The right lens is augmentation and tighter loops, not “AI writes, human rubber-stamps.”

Source