Generated by Codex with GPT 5.6 Sol High

The Pragmatic Engineer surfaced its September 30 episode, “Distributed databases with Peter Mattis”, a conversation with the Cockroach Labs co-founder and CTO about building storage systems at Google, turning Spanner’s ideas into a commercial database, and using AI agents without abandoning engineering judgment. The most useful thread is not a prediction that databases or programmers disappear. It is that durable abstractions and fast verification let one expert explore far more designs than before.

Storage design follows physical constraints

Mattis’s career supplies a compact history of modern data infrastructure. Gmail’s original storage layer used B-trees to track threads and unread counts. Later, Google replaced the three full replicas used by Google File System with Reed–Solomon erasure coding in Colossus. The newer scheme cut storage overhead by roughly one third while increasing resilience: redundancy came from mathematical fragments rather than complete copies.

Those choices shaped what could be built above the filesystem. Colossus was append-only, so Spanner could not rely on ordinary B-trees whose nodes are updated in place. Log-structured merge trees were a better fit because they turn writes into sequential appends and reconcile data later. Google popularized that pattern with LevelDB; RocksDB extended it; CockroachDB initially used RocksDB before Mattis wrote Pebble, now its storage engine.

The episode makes these structures feel less like a catalog of fashionable technologies and more like responses to constraints. B-trees pack related keys together and exploit cache locality, which is why Mattis could replace pointer-heavy tree implementations with faster, smaller versions. LSM trees fit immutable or append-oriented storage. Replicated consensus needs a quorum that can distinguish failure from disagreement, which is why CockroachDB defaults to three replicas and uses as many as five for some system tables. Extra copies improve fault tolerance but add latency. There is no architecture without a bill.

This habit of reasoning from hardware and failure modes also explains Mattis’s emphasis on keeping rough latency numbers in his head. A network round trip within a zone has fallen from milliseconds to about 100 microseconds since the Colossus era, but global communication eventually meets the speed of light. Faster software cannot optimize away physics; sometimes the surprising route—up to a satellite laser link and back down—can beat terrestrial fiber because light travels faster through a vacuum.

AI raises the value of taste and feedback

Mattis says AI brought him back toward hands-on coding after management had pulled him away. Before agents, he estimates that he shipped about 100,000 lines of database-grade code in a productive year. Now he can launch several experiments that once would have occupied a week each and compare the results in parallel. The experience is less like an uninterrupted coding trance and more like supervising a group of fast research assistants.

That leverage depends on expertise. An agent can generate implementations, but the engineer still needs to notice when a standard map is wasting memory, understand why an append-only layer favors an LSM tree, or design tests that expose a consensus failure. In this account, domain knowledge is not replaced by cheaper code. It becomes the filter that chooses promising experiments, identifies bad assumptions, and turns generated output into a dependable system.

The same change is spreading beyond engineers. Cockroach Labs gave non-developers an internal app-building platform, and employees reportedly created roughly 1,000 tools in a few months, including HR workflows and finance dashboards. That is evidence of latent demand for small software that conventional engineering queues would never prioritize. It is not yet evidence that all of those apps are maintained, secure, or valuable over time.

Mattis goes further and predicts that engineers will eventually stop reading most generated code, much as they stopped inspecting assembly. That forecast is provocative precisely because his career was built around low-level scrutiny, including service as a C++ readability reviewer at Google. But the analogy is incomplete. Compilers have narrow specifications and mature validation; coding agents act on ambiguous intent, external context, and evolving systems. Teams may review fewer lines, yet they will need stronger behavioral tests, observability, ownership, and design review before code can safely become an implementation detail.

The episode is an experienced participant’s account, not a controlled productivity study. Its line counts, quality assessment, and internal-app total are self-reported, and it does not provide defect rates or long-term maintenance data. Its durable lesson is narrower: AI compounds engineering ability when a system already has clear constraints, testable behavior, and experts who know what to measure. Faster production matters, but the advantage comes from shortening the loop between a design idea and trustworthy evidence about whether it works.