Skip to content
TNPL

Contents

The argument, then the language

The first half is the argument, with measurements. It follows the two transitions that already happened, examines why models emit the languages they do, and quantifies what it costs to have a machine write in a language designed around human working memory. The second half designs the language that follows.

On method

How the book is put together

Part I is history, and it is not decoration

Programming has been through this twice before, and the arguments made against each transition are on the record — made by intelligent people, for defensible reasons, and mostly correct at the time. Knowing how those arguments went is the fastest way to see the shape of this one.

Part II demonstrates; it does not survey

Each cost is shown on a worked example small enough to check by hand and reproduce from the labs — an existence proof that the cost is real and has the shape claimed. Where a number is owed and has not been taken, the chapter says so rather than estimating one.

Part V is a working language

The labs compile and run. Nothing in the book is pseudocode, though Appendix A.12 is explicit about the fragment of computation the language covers today — which is smaller than a reader might assume from the argument around it.

If you read one chapter, read 21

It specifies a structured diagnostic record: a stable code, the fragment at fault, the obligation not met, whether it is false or merely unproven, the finite set of legal repairs, and how much of the program may be touched. Anyone building a coding agent can adopt that record next week, against Python or Rust or anything else, without writing a line of AIR.

Part I

Every Language Has an Author

Three eras, two transitions, and the same reason each time. What each era's programmer actually held — and who writes it now.

  1. 1The Author Changed
  2. 2When Humans Wrote the Machine
  3. 3Assembly: The First Human Interface
  4. 4High-Level Languages: Programming for the Brain
  5. 5The Great Disappearing Act
Part II

AI Is Wearing Human Clothes

Why models emit Python, and what it costs to have a machine write in a language shaped around human working memory. Each cost is shown on a worked example.

  1. 6Why Does a Model Write Python?
  2. 7Python Was Designed for Us, Not for It
  3. 8The Cost of Pretending to Be a Human Programmer
  4. 9Why Machine Code Is the Wrong Answer Too
Part III

The Forgotten Middle

The languages machines already speak to machines — SSA, LLVM IR, MLIR — what they genuinely do, and what they were never asked to do.

  1. 10The Languages Machines Already Speak to Machines
  2. 11SSA, and the Compiler's Private Language
  3. 12MLIR: One Program, Many Levels of Meaning
  4. 13Why None of These Were Built for a Machine Author
Part IV

Designing the Fourth Language

What a machine author does not need, and what it does: intent and freedom, constraints and contracts, effects, capabilities and obligations.

  1. 14What Machines Don't Need
  2. 15Intent and Freedom
  3. 16Constraints, Contracts and Invariants
  4. 17Effects, Capabilities and Obligations
Part V

The Language

AIR, in full. It parses, it verifies, it compiles, and it runs — and every laboratory exercise is reproducible with Python and Clang.

  1. 18A First Program
  2. 19Values and Types
  3. 20Fragments, Identity and Repair
  4. 21Diagnostics as a Language Feature
  5. 22Effects and Capabilities in Practice
  6. 23Contracts
  7. 24Freedom
  8. 25From Intent to Native Code
  9. 26Calling the World
Part VI

Closing & Reference

Eight observations that would prove the book wrong — including two measurements it has not taken — then the AIR reference manual, the labs, sources and a glossary.

  1. 27What Would Falsify This Book
  • AThe AIR Reference Manual
  • BThe Labs
  • CSources and Further Reading
  • DGlossary

Who this is for

Anyone who writes software, reviews it, buys it, or is responsible for it working

You should be comfortable reading a program. You do not need to know how a compiler works — Part III explains what you need, and no more than that. If you have never seen assembly, you will by page 30. If you write compilers for a living, Part III will be familiar and Part IV will not.

What you need to run the labs: a machine with Python 3 and Clang on it.

27 chapters · 4 appendices · 15 figures · 178 pages