0. Preface (pocket version)

TL;DR (5 lines)

Vitte favors explicit contracts over implicit convention.
A philosophy chapter still needs code, not only prose.
The smallest useful example already separates domain and transport.
Invalid paths are part of the design contract.
Readable structure is a technical property, not decoration.

Concrete Problem

Readers often learn syntax before learning the design contract of the language. That creates code that compiles but is hard to maintain, review, or debug.

Coherent example

space demo/philosophy

form BuildRequest {
  name: string
  retries: int
}

pick Decision {
  case Accepted(name: string)
  case Rejected(code: int)
}

proc decide(req: BuildRequest) -> Decision {
  if req.name == "" { give Decision.Rejected(11) }
  if req.retries < 0 { give Decision.Rejected(12) }
  give Decision.Accepted(req.name)
}

entry main at core/app {
  return 0
}

Global explanation

The chapter is not about one token. It is about explicit contracts, clear boundaries, and stable failure surfaces. The example is small, but it already separates domain data, decision logic, and process entry.

Short exercise

Take one vague helper in your own code and rewrite it so that the domain input, the branch conditions, and the result boundary are explicit.

Next best action

Keep the example small, reproduce it locally, then continue to the full chapter if you need the broader context.