Skip to content

Book I.

Writing: thirteen propositions, in order of proof.

Essays and field guides on engineering with AI, software architecture, distributed systems, and the semantics of natural language. Each carries a figure drawn from its own argument.

XIII of XIII shown
  1. XIII
    peoplewikiindex1,266 files · one OKF bundle · three readers
    A stack of 1,266 markdown files joined by three lines to its readers: people, the wiki and the retrieval index
    Your Docs Are a Corpus Now To prove: Why a repository's twelve hundred markdown files now have three readers (people, a wiki and a retrieval index), and what happened when we adopted Google's Open Knowledge Format, turned our READMEs into a company wiki and pointed our own RAG product at our own codebase. AI · Architecture · Tools Nov 1, 2026
    16 min
  2. XII
    ∧∨status = indexedcreated ≥ Oct 1name ~ reportSQLWHERE … AND (… OR …)CQLpushdown + residualchart
    One filter tree, an AND of a status clause with an OR of a date and a name clause, folds into a SQL WHERE clause, a CQL query with a residual predicate, and a bar chart
    One Query Language, From Filter Chip to Chart To prove: How a small, typed query language can carry a platform from the filter chips on a list page to a pivoting analytics engine, given one filter tree, one field schema and one sort form, compiled by a fold into SQL, CQL or whatever comes next. Architecture · Distributed systems · Patterns Oct 31, 2026
    14 min
  3. XI
    1 min1 hr1 day1 wkEpicStoryTaskagent builddone-done
    Agent build time against time until done-done for epics, stories and tasks, on a log scale from one minute to one week
    Rethinking Agile in the Age of AI To prove: Agile's values still hold, but its practices were tuned for a world where code was expensive. What six months of AI-driven development suggests about roles, design, review, estimation and the Definition of Done. AI · Architecture Oct 28, 2026
    14 min
  4. X
    51%no theory32%a theoryshare of commits that fix or refactor
    Share of commits that fix or refactor: 51% without a theory, 32% with one
    Six Months of Enterprise Development with AI To prove: What six months, 1,200 commits and 594 stories of building a production AI platform with agents taught me about what holds, what breaks, and where AI still falls down. AI · Architecture Oct 28, 2026
    18 min
  5. IX
    4 > 7 / 2
    Seven replicas split by a network partition; the four-node majority can still commit
    The Top 50 Techniques for Distributed Engineering To prove: That nearly every distributed system is built from the same fifty techniques (sharding, quorums, idempotency, backpressure, circuit breakers and the rest), each shown here with a Go or Python implementation and, where it helps, a diagram. Architecture · Distributed systems · Patterns Jul 13, 2026
    34 min
  6. VIII
    XVI parts · C patterns
    A ten-by-ten grid of one hundred cells filled in reading order across sixteen parts
    100 Patterns for Production Go and Python To prove: That a hundred design patterns, concurrency idioms, resilience strategies and architectural habits are what separate production Go and Python systems from prototypes, catalogued with an example for each. Architecture · Distributed systems · Patterns May 6, 2026
    62 min
  7. VII
    inherit · diagnose · defend
    A service graph with five sound edges and three broken red edges that students inherit, diagnose and defend
    Professional Software Engineering for AI and Distributed Systems To prove: That the gap between writing code and engineering production systems can be taught, given a graduate course built on deliberate technical debt, an architecture defense and AI used as a force multiplier. AI · Architecture · Distributed systems · Teaching Mar 1, 2026
    16 min
  8. VI
    317 commands · 7 templates · 3 tiers
    Three concentric model tiers carrying seven template squares and seventeen command dots
    Anatomy of an AI Engineering System To prove: How seventeen slash commands, seven templates and three model tiers, each of them short and single-purpose, turn Claude Code into a full software development lifecycle. AI · Architecture · Tools Feb 26, 2026
    14 min
  9. V
    EntrypointsControllersWorkflowsPipelinesServicesRepositoriesClientsFoundationCore interfaces
    Nine stacked layers from entrypoints to core interfaces with dependencies pointing down only
    The Ideal Repository Structure To prove: That strict layer boundaries, enforced by the directory structure itself, keep a codebase from decaying, with a detailed tour of interface-first, layered monorepo design in Go and Python. Architecture · Patterns Feb 24, 2026
    24 min
  10. IV
    1 skeptic2n
    A binary tree that doubles at each of five levels, from one skeptic to a chain reaction
    How I Learned to Love the Bomb To prove: Why I went from skeptic of AI-assisted programming to building an engineering system around it, and why what won me over was not the models but the discipline you wrap around them. AI · Architecture · Tools Feb 22, 2026
    11 min
  11. III
    RecoveryAuthTransactionObservabilitycall in · unwind out
    A call enters through Recovery, Auth, Transaction and Observability rings, reaches the service, then unwinds
    The Decorator Pattern for Observability and Resilience To prove: Why logging, metrics, retry and circuit breaking belong in wrappers rather than in your business logic, with examples in Go and Python. Architecture · Distributed systems · Patterns Feb 22, 2026
    6 min
  12. II
    t(e→t)→te→teverytall senatorapprovedthe new bill∀x[(tall(x) ∧ senator(x)) → approved(x, ιy[new(y) ∧ bill(y)])]
    Typed composition tree for the sentence “Every tall senator approved the new bill” with its logical form below
    From Dependency Parses to Montague Semantics via Vector-Grounded Concept Bases To prove: That Universal Dependencies parses, a Montague-style typed lambda calculus and concept bases derived from vectors can be fitted together into a single compositional semantics pipeline, and how. Semantics Jan 31, 2026
    15 min
  13. I
    nvimgitzsh$ ./install.sh
    A terminal window split into neovim, git and zsh panes, rebuilt by one install command
    My Development Environment To prove: A tour of my macOS setup (zsh, Neovim, tmux and 80-odd command-line tools), all of it kept in one dotfiles repo that installs with a single command. Tools Jan 15, 2026
    9 min