How Does Geoffrey Litt at Notion Understand Code Written by AI Agents?

TL;DR

Developers should understand agent-written code because comprehension keeps them active creative participants, even as agents improve at correctness checking. Geoffrey Litt of Notion recommends personalized explainer documents, intuition before implementation details, purposeful interactive figures, literate code diffs, and quizzes that expose false confidence. Read on for practical ways to prevent cognitive debt while benefiting from faster coding agents.

Transcript

[music] What's up? Yeah, thank you for coming to the design engineering track at AI. Is everyone having fun? Yeah, I think this is going to be a great track, so get excited. All right, let's get going. Um, my name is Jeffrey Lit. I'm a design engineer at Notion currently and I'm here to drop a hot take for this room. Maybe I think it is still impor... Read More

Key Insights

• Understanding is necessary for creative participation, not only correctness checking. A human who understands the system can recombine concepts, make informed creative leaps, and generate the next idea, while someone several layers removed from the implementation has fewer meaningful ways to guide the project.
• Correctness checking is becoming less dependent on humans because agents can increasingly evaluate whether work matches a specification, avoids production failures, and follows an acceptable architecture. Better verification loops therefore reduce one human role without eliminating the separate need to understand what was built.
• Cognitive debt is the accumulated loss of understanding that develops when people accept rapid agent-generated changes without keeping up conceptually. It may remain hidden while development feels productive, but eventually the human can no longer participate effectively because the system's behavior and structure have become unfamiliar.
• Education provides practical models for understanding agent-written code. Instead of relying exclusively on line-by-line review, developers can apply teaching principles, personalized explanations, interactive experiences, and knowledge checks to absorb changes more efficiently while continuing to benefit from the speed of coding agents.
• An effective code explanation begins with relevant system background rather than immediately describing the latest change. This foundation can be personalized or skipped when already understood, allowing the material to meet the reader at an appropriate level before introducing implementation-specific details.
• Intuition should precede implementation details in an explainer document. A concise description of the change's essential goal, supported by concrete examples, gives the reader a mental model that makes subsequent code easier to interpret than an unexplained sequence of modified files.
• Interactive figures can reveal behavior that static prose cannot communicate as directly. In the Zen garden example, moving rocks through a small simulation exposes coordinates and painting-layer changes, although interactivity must be used purposefully because unnecessary interaction can become a distraction or crutch.
• Quizzes expose the gap between reading and genuine comprehension. A developer can finish an explanation believing the material was understood, yet fail to answer a basic question afterward. Active recall questions make this misunderstanding visible and can reinforce memory beyond the initial review.

Questions & Answers

Q: Why should developers understand code written by AI agents?

Understanding enables developers to participate creatively in future work, not merely approve or reject an agent's output. Knowledge from one development loop becomes the foundation for generating ideas, making decisions, and guiding subsequent loops.

Q: What is cognitive debt in AI-assisted software development?

Cognitive debt is the accumulated loss of understanding that occurs when agent-generated changes arrive faster than a developer can absorb them. It may remain hidden while development feels productive, but eventually the system can become too unfamiliar for the developer to guide or discuss effectively.

Q: Why is correctness review insufficient for agent-generated code?

Correctness review asks whether work matches a specification, avoids production failures, or follows an acceptable architecture. Agents are improving at these approval-or-rejection checks, while human understanding remains necessary for forming new ideas and participating creatively.

Q: How should an explainer document for agent-written code begin?

It should begin with relevant background about how the system works before describing the latest change. That foundation can be personalized to the reader's existing knowledge or skipped when the material is already understood.

Q: Why should an explanation present intuition before implementation details?

A concise statement of the change's central goal gives the reader a mental model for organizing later technical details. Concrete examples can strengthen that intuition before the explanation introduces modified code.

Q: How can interactive figures explain software changes?

Interactive figures let developers manipulate simplified representations of the behavior affected by a change. They can reveal relationships that static prose cannot, but the transcript recommends using them purposefully rather than adding interaction without a clear teaching goal.

Q: What are literate code diffs?

Literate code diffs arrange modified code as a guided conceptual narrative instead of following raw file order. Explanatory prose introduces relevant sections and clarifies how each part contributes to the overall change.

Q: How do quizzes improve understanding of agent-written code?

Quizzes require active recall and reveal whether passive reading has produced confidence without genuine comprehension. They help developers identify gaps immediately and verify that they remain meaningfully involved in the work.

Summary & Key Takeaways

• Who: Geoffrey Litt is a design engineer at Notion who argues that people should still understand how code works.

• Number: AI agents are landing 50,000-line PRs, making line-by-line review increasingly difficult.

• Definition: Understanding to participate means learning enough from each development loop to generate ideas and guide later work.

• Definition: Cognitive debt is the accumulated loss of understanding caused by accepting rapid changes without keeping up conceptually.

• Compare: Correctness checking produces approval or rejection, while comprehension builds knowledge that supports creative participation.

• Tool: Personalized explainer documents teach relevant system background before presenting a specific code change.

• Tool: Literate code diffs organize modifications as a guided conceptual narrative instead of raw file order.

• Tool: Purposeful interactive figures provide intuitive views of behavior that can be difficult to communicate through prose alone.

• Tool: Quizzes expose false confidence by testing whether developers can actively recall and use an explanation.

• Step 1: Establish the reader's relevant system background before explaining the latest implementation.

• Step 2: Present the change's central intuition and concrete examples before showing code details.

• Step 3: Reinforce understanding with guided code, purposeful interaction, and knowledge checks.