Ron Minsky explains Jane Street’s approach to reliable agent-assisted development at Bug Bash 2026, hosted on Antithesis’s channel. The hour-long talk argues that established engineering practices become more valuable when agents write code. Human attention and understanding remain the scarce resources.

Types make rules persistent · 07:06–18:38

  • Type systems check how values can be used before a program runs. Minsky treats them as tools for designing and enforcing a system’s rules.
  • His HTML example uses an interface that requires text to be safely escaped before insertion. Forgetting that conversion produces a type error.
  • His network example replaces a list of configuration commands with fields that encode which settings are optional and which can repeat.
  • Choosing the right data representation removes contradictory configurations and simplifies code elsewhere: “make illegal states unrepresentable.”
  • Agents need fast, precise feedback. Compiler errors expose relevant constraints when needed, without fitting the whole system into the model’s context.
  • Small typed interfaces can enforce rules across a large codebase. Their guarantees survive forgotten prompts and long sessions.

Expect tests make behavior readable · 18:38–26:00

  • An expect test stores a program’s printed output beside the code that produced it. Changes appear as a reviewable difference.
  • Capturing whatever the program prints is only a starting point. Someone must check that the result is correct and worth preserving.
  • Design the output for understanding: short behavioral traces, carefully chosen examples, or even text-based waveforms for hardware tests.
  • Jane Street also builds deterministic simulations at the library level. Tests control clocks, networks, and other services to reproduce interactions quickly.
  • These small simulations complement broader system testing. Their fast feedback helps both developers and agents investigate behavior.

Examples can carry intent · 26:00–33:44

  • Minsky defends selected examples alongside property-based tests, which check general rules across many generated inputs.
  • Strong types and simple implementations can make a few carefully chosen examples surprisingly informative. They still cannot establish every property.
  • A committed example records what a developer considered important. Agents and future maintainers inherit that context.
  • His spreadsheet comparison: ordinary code exposes logic but hides the flow of data. Spreadsheets expose data while scattering the logic.
  • Readable expect tests combine compact code with visible behavior. A reviewer can inspect a logic change and the resulting changes to execution traces.

Code review preserves the conditions agents need · 33:44–45:32

  • Review catches bugs, spreads knowledge, and pressures authors to make changes understandable to another person.
  • Agents benefit from coherent, well-maintained codebases. Minsky finds them much weaker at preserving simplicity while completing individual tasks.
  • Passing tests can coexist with duplicated logic, hard-coded exceptions, and growing fragility. That deterioration makes later agent work harder.
  • Cheap generation changes the social contract: a quick request to an agent can hand a maintainer a substantial review burden.
  • Familiar signals of care become less reliable. Polished-looking code can conceal shortcuts, including changes that weaken the tests meant to check it.
  • Agents can also reduce review effort: split a feature into smaller changes, write clarifying tests, and prepare a guided walkthrough of the diff.

Formal verification may become affordable · 45:32–54:28

  • Formal verification proves that a program satisfies a precise specification. Jane Street historically found its cost hard to justify for most work.
  • Minsky is reconsidering that trade-off as agents help translate domain expertise into proofs and proof-assistant code.
  • Possible directions include refinement types, which attach more precise conditions to values, and proofs that a change preserves specified behavior.
  • Another possibility: a person writes a simple reference implementation, then an agent builds a faster version and proves the two agree.
  • This is an exploratory investment. He explicitly says the current models may be insufficient and the approach might not work out.

Q&A: automation, richer types, and shared style · 54:28 onward

  • Automated code review is useful for improving patches and auditing recurring mistakes. Minsky separates that from humans understanding the systems they own.
  • Richer type systems must earn their complexity through usable errors, good ergonomics, and fast feedback. Agents may change their economics.
  • Verification can influence program design. His hope is that proof-guided optimization expands what engineers can achieve, rather than simply slowing development.
  • A shared code style makes ownership transferable. Agents generally imitate nearby code well, which also means they can reproduce nearby bad practices.
  • The closing distinction is between improving agent effectiveness and improving human understanding. Development tools should support both.

“The precious resource remains human attention.”

Caveat: These are Minsky’s observations from Jane Street’s unusually controlled tooling environment. The formal-verification proposals are possibilities, not demonstrated production results.