Agents Made Code Free. Maintaining It Didn't Get Cheaper.

Dmitry Buykin, Maersk18:04 · Nov 2026 · 4,335 views
Thumbnail for Agents Made Code Free. Maintaining It Didn't Get Cheaper. Watch on YouTube
TL;DR
  1. 1

    Coding agents make code and operational entropy grow quickly, so teams need weekly pruning and feedback loops instead of waiting for a large rewrite.

  2. 2

    Production correctness depends on expert-owned rules, real-task replays, runtime controls, and evidence that can change the team's mind.

  3. 3

    A repository should be audited with explicit questions about time, space, reality, mind, power, and attention before one person becomes the bottleneck for every change.

Summary

Dmitry Buykin describes what happened after coding agents wrote most of a large production system. A rewrite removed unused tests and boilerplate, but the mess returned. His replacement is a weekly process that keeps change below a line the team can still inspect. The system runs across 110 countries, about 10,000 scenarios, and roughly three quarters of the system is prose instructions. Buykin argues that tests alone cannot establish correctness because business rules need expert judgment. Experts own decision tables, while agents and code handle repeatable work. Runtime controls restrict what the model sees and what it can change. The team replays real tasks, makes checks fail deliberately, tracks skipped work, and turns expert feedback into evals. Each week, unused variants and their tests are removed. Buykin is direct about the human cost: when one person cannot explain recent changes, the process is already failing, even if the dashboard is green.

Key ideas
00:00

Weekly small sweeps keep growth below what the team can inspect

Buykin began with two bad choices: let the project drown in accumulated changes or rewrite it and lose useful pieces. The rewrite did not hold because agents rebuilt the mess. His third option is to stay below a line where the amount of change remains reviewable. The team does small sweeps every week and builds feedback loops into the system. The goal is not a permanent cleanup. It is a recurring process that removes dead work before it becomes too large to understand.

01:22

Correctness depends on experts because instructions carry business rules

The system runs in 110 countries with about 10,000 scenarios, and Buykin estimates that about three quarters of it is prose instructions. Mutation testing found that breaking a sentence in those instructions caused almost none of the tests to turn red. Tests can show whether code survived a rewrite, but people must decide whether a business rule survived. Experts review tasks as the agent saw them, sign the business description, and own decisions that vary by market or local law.

04:41

Repeated agent paths become tools while variable decisions stay readable

Buykin treats an agent's repeated path through instructions as a walk. When the same walk repeats and agrees across countries, the team turns it into a workflow tool and removes the instructions that merely described those steps. Instructions retain the decisions that still vary. Code prepares facts and carries out the decision, while experts own the decision table. The model selects a row, and a person takes over when no row fits. The boundary can move in either direction when experts can or cannot read the rule.

07:19

Runtime context and write paths limit what an agent can do

When agents were allowed to choose what to load, they loaded everything and invented a pricing check because prices appeared in their context. Buykin's runtime now decides what the model sees. The model passes a short handle for data held by the runtime, which checks that data before a write. The team also controls changes twice, during development and at runtime. Only code opens the permitted path, and several checks stand between a proposed write and its completion. A journal prevents a retry from running the same action twice.

09:41

Human attention needs its own gauges

The system had controls, but nothing protected Buykin's attention. He first read every change, then the volume became too large and he stopped. His first gauge is personal: when he is tired and cannot explain what changed, he stops and fixes the process. A green dashboard does not override that signal. Other instruments watch how changes behave, including blast radius. The team replays a new rule over several thousand past sessions before adding it, then investigates where signals or counts jump.

12:27

Real tasks and deliberate failures provide stronger evidence than green checks

Buykin ranks evidence by what it proves. A replay on real tasks is at the top. Before data arrives, the team writes down what would prove a rule wrong, and every new check must fail once on purpose before it is trusted. Real tasks are frozen as a set and replayed against the old and new versions. If no real task reaches a branch, the team calls that no evidence. A second agent checks the work with a checklist without seeing the author's reasoning, so it cannot simply agree.

11:38

Feedback must leave the session and enter ledgers

Users and experts cannot depend on Buykin to carry every issue between them and the agents. Each feedback loop writes to a ledger, and every issue connects to a root cause. The team keeps files for what happened and for what is true now. The next agent session starts from the current truth rather than from the previous session's temporary memory. Expert notes become evals, and an agent searches related slices for the same failure. Fixes are applied only where the failure is confirmed because markets and local laws intentionally differ.

15:33

Weekly pruning removes variants that real use no longer reaches

Buykin's final process uses real use every week to decide what stays. A variant that no real task reaches gets a name and evidence before removal. Its test is retired with it, because tests can keep dead variants alive and agents can preserve every option still mentioned by a test. The process uses ratchets whose counts can only go down, alongside other gauges for code growth and branching. The aim is to remove dead structure in small, evidenced steps rather than wait for another drastic rewrite.

"When I'm tired and I can't explain what changed, that's the signal."10:27
Who should watch
  • Your coding agents now write most of the repository, but reviews are becoming a queue through one senior engineer.
  • You maintain rule-heavy software across countries or business contexts, and ordinary tests do not show whether the written instructions remain correct.
  • Your team is considering a rewrite because the repository has accumulated unused tests, variants, workflows, and agent-generated changes.