The Centrifuge Method: Spin the Stupid Out of AI

Lada Kesseler describes a coding-agent workflow built around small refinement loops rather than expecting a first attempt to satisfy every requirement. Her “centrifuge” metaphor means writing an artifact, reading it back against a goal, and revising it with human direction—not a training method or a guarantee that repeated self-review removes every mistake.

This summary uses the video's English captions, saved with kind caption; it does not include an original-audio check. Workflow benefits are Kesseler's reported experience, not controlled evaluations. The podcast is brought to listeners by Tessl, and the hosts discuss its agent product during the interview.

Main points

• Keep standing instructions small and load procedures when needed. Kesseler separates cross-project ground rules—such as challenging her assumptions and reporting problems early—from detailed workflows. She describes a carefully maintained 72-line user-level CLAUDE.md, with additional instructions discovered through skills or project files rather than putting every process into the always-present context. 06:04–10:08(opens in a new tab)
• Teach a concrete TDD process, then test the skill in a fresh session. Instead of only saying “use test-driven development,” she walks the agent through a session, asks it to record the steps, clears the session, and corrects failures when it applies the recorded process. A skill's description tells the agent when to invoke it; vague, overlapping descriptions make selection harder. 10:08–12:42(opens in a new tab)
• The centrifuge is a write-read-revise loop with a specific goal. Have the agent take one step, save the result to a file, stop, read it back, and assess what still needs changing. Her writing example includes human feedback about direction and voice between loops. The improvement she reports comes from iterative refinement with that feedback, not simply accepting the first generated draft. 12:42–16:11(opens in a new tab)
• Separate implementation from focused quality checks. Kesseler reports better results when asking the agent to find and fix particular problems after generating code rather than asking it to enforce many standards at once. The hosts describe Tessl checks focused on individual standards. She describes experiments in which deterministic checks flag a long method or dead code, then invoke a focused agent recipe, linter, or formatter. Her explanation in terms of limited attention is a working interpretation, not a demonstrated account of model internals. 16:11–21:14(opens in a new tab)
• Explore an unclear problem before committing to code. For unfamiliar problem spaces, she uses a Markdown instruction file plus an agent as a disposable stand-in for application logic. Experiencing that rough user flow helps reveal what to build without committing early to one implementation. She explicitly warns against putting this sketch prototype into production. 21:14–24:32(opens in a new tab)
• Keep a human mental model of the system. Kesseler distinguishes a good result on one task from managing architecture across levels. She says she still has to hold the system's mental model and has not figured out how to apply refinement loops across those levels. 24:32–26:10(opens in a new tab)
• Ask for alternatives, not just the agent's next question. She recommends steering the interaction: ask the agent to show options, mark its recommendation, and expose paths not taken. Concrete alternatives make it easier to discover preferences and reject a poor choice. For review, she favors AI refinement followed by human review, with the result presented in a form the human can follow. 27:45–31:58(opens in a new tab)
• Use two testing levels: agent feedback and human-readable behavior. Kesseler uses low-level TDD tests to give the agent executable feedback, but warns that it can weaken or comment out tests. For her own review, she uses pytest and approval testing to show domain-level actions and results—for example, an API call and its returned output. She inspects a captured result and approves it as the baseline for later comparisons; approving an incorrect result would lock in the wrong expectation. She wants these higher-level expectations to be harder for the agent to edit than internal tests. 31:58–35:25(opens in a new tab)
• Build trustworthy operations before assembling a software factory. Kesseler is interested in automation but skeptical that adding more agents compensates for unreliable building blocks. She reports having a refactoring process she trusts for scoped changes while still experimenting with reliable knowledge extraction. Her current work is largely greenfield and prototyping; she says she would stay closer to the code and emphasize a strong, fast test suite in an existing system. 35:25–39:39(opens in a new tab), 41:13–42:49(opens in a new tab)

Still exploratory

Kesseler wants to explore better refinement loops and Martin Dilger's approach: diagram behavior, generate code in isolated slices, and retain events from which UI-facing views are constructed. She sees potential for managing complexity, but has not tried the approach and is concerned about duplicated code and numerous views. 42:49–45:20(opens in a new tab)