If you’ve spent any time working with AI coding agents like Cursor, Claude, or Devin recently, you’ve probably experienced a specific kind of modern whiplash. You ask for a feature, and seconds later, the agent spits out 500 lines of perfectly functioning code across seven different files.
It’s magical—until you realize you have no idea how any of it actually works.
As AI agents write an increasing share of our code, keeping up with their output is becoming significantly harder. Former Tesla AI Director Andrej Karpathy recently nailed this sentiment: “You can outsource thinking, but you cannot outsource understanding.”
Software engineer and researcher Geoffrey Litt recently went viral on X (formerly Twitter) for diving deep into this exact problem. He argues that as AI gets smarter, understanding is the new bottleneck. If we merely verify code (checking if it’s “right” or “wrong”), we quickly accumulate cognitive debt. Eventually, the human team loses the plot. To truly participate in continuous software iteration, we have to understand it.
To solve this, Litt proposed three practical, highly effective techniques for working with coding agents without losing your grip on the codebase.
1. The Narrative Diff (And The Speed-Limiter Quiz)
Usually, when an agent finishes a task, you look at a Git diff. A standard diff is just an alphabetical list of file changes—it has no narrative and offers zero background context.
Instead, Litt suggests leveraging agents to give us structural explanations. He built a custom /explain-diff skill that generates a rich, readable document (in HTML, Markdown, or Notion) following three core principles:
- Background First: Before explaining what changed, the AI explains the system’s baseline. (e.g., If the agent changed the camera logic in a 3D engine, it first explains how the engine’s original perspective system works).
- Intuition Over Details: The AI explains the high-level goal and concepts (like “isometric projection”) before dumping raw code on you.
- Narrative Structure: Instead of a file checklist, it writes the diff like a story, weaving explanations seamlessly with code snippets.
But reading can give you a false sense of security. To ensure you actually absorbed the knowledge, Litt borrows an idea from researchers Andy Matuschak and Michael Nielsen: Embedded Quizzes. At the bottom of the narrative diff, the agent generates a quick 5-question interactive quiz. If you don’t pass the quiz, you can’t push the code.
In a world where AI iterates faster than human comprehension, this quiz acts as a crucial “speed limiter” to keep the human safely in the loop.
2. Microworlds: Using Agents to Build “Understanding Tools”
The second technique draws inspiration from computing pioneer Seymour Papert and his concept of “Mathland” (the idea that to learn math natively, you should inhabit a world governed by math, much like moving to France to learn French).
Can we build visual “microworlds” to intuitively understand our code? Yes—and agents are uniquely good at this.
Instead of just asking an agent to fix a bug or run a migration script, ask the agent to build a tool that helps you understand the problem. Litt shared two brilliant examples:
- The Custom Debugger: While writing a complex Prolog interpreter, Litt couldn’t conceptualize what was happening under the hood. He had his AI agent build a bespoke visual debugger where he could step through logic rules, scrub a timeline back and forth, and inspect the call stack.
- The Migration Mini-Game: When migrating a personal site to a new framework, Claude wrote a script that could do it instantly. But a massive automated PR is a nightmare to review. Instead, Litt had Claude build a “Command Center” UI—a side-by-side view of the old and new sites with a button to execute the migration step-by-step.
The takeaway? Agents shouldn’t just write production code; they should write throwaway code specifically designed to help humans understand the production code.
3. Shared Spaces for Collaborative Comprehension
When you and your teammates share a mental model, communication is frictionless. You have a shared vocabulary and can bounce ideas around instantly. But when AI agents are siloed in individual IDEs, that shared context breaks down.
The solution is to push AI outputs into Shared Spaces. When agents generate technical proposals, architectural changes, or narrative diffs, the default destination should be a collaborative canvas (like Notion or Google Docs).
This transforms the AI from a solitary coding assistant into a team facilitator. It allows engineers to highlight, comment, debate, and synthesize the AI’s output together. We move from isolated thinking to collaborative understanding.
Final Thoughts: Augmentation > Automation
More than 50 years ago, Turing Award winner Alan Kay envisioned the computer as a new medium—better than a book—to teach people how to think about the world.
The true promise of AI in software engineering isn’t just mindlessly automating humans out of a job. It’s about augmentation. By forcing agents to explain their work through narrative diffs, building custom microworlds for complex logic, and creating shared spaces for team debate, we can use AI to deepen our understanding of the very systems we are building.
The code might belong to the agent now, but the understanding must remain ours.
What do you think? Are you feeling the “cognitive debt” of AI-generated code in your current projects? Let me know in the comments below!