The case for a thin contract.

Abstract. Vibe-coding gives you speed but takes away review, reuse, and provenance. Traditional code keeps all three but costs time you don't have. Anglish is the smallest amount of structure that preserves the ergonomics of natural language while restoring what we lose without it.

The vibe-coding loop, and what it costs.

Modern no-code platforms — visual editors, drag-and-drop pipelines, and large language models that take prose and emit code — let subject-matter experts describe what they want and leave the platform to decide how. Speed, accessibility, and creativity all jump.

But the same iteration loop that makes small scripts fly produces a long tail of costs once the system has to be reviewed, reused, or shipped. Two structural costs drive everything else:

• Comprehension overhead. The AI rewrites hundreds of lines in a single pass; a human reviewer must re-read all of them, because any change might alter behaviour.
• Generation drift. A minor prompt tweak renames variables, reorders functions, or swaps libraries. After enough cycles, the code no longer matches the version that was reviewed.

From these, five recurring problems emerge:

1. Super-linear review time. Each new feature inflates the diff surface; review cost rises faster than line count.
2. Fragile reuse of trusted modules. Calling "the GDPR redactor" in prose does not guarantee the audited binary is the one that runs.
3. Hidden control-flow choices. Polling vs. batching, retries, thread-spawning — silently changes between iterations.
4. Unstable identifiers. Without a schema, names drift and implicit flows break.
5. No provable lineage. No cryptographic link between the reviewed text and the deployed binary.

The Anglish contract.

Generative AI shifted programming from a solo human task into a collaborative process. The author's job is no longer to produce code directly, but to steer and constrain a system that can now generate large portions of software. The risk is open-ended generativity without correctness, traceability, or reproducibility.

An Anglish program is a thin, declarative contract. It states:

• The goal and how it decomposes into sub-problems.
• The intended solution schemes for each sub-problem.
• The decision boundaries — which choices the AI may make freely, and which the author fixes.
• The conditions for recombining sub-problem results into the whole.

The compiler treats the contract as the source of truth. Generated code or agent behaviour is accepted only if it conforms to the declared structure. Outputs are tagged with authorship metadata; the assembler signs and seals a reproducible .mex archive.

Boundaries you can read.

The contract is granular: each sub-problem can be governed by its own boundary type. A declarative boundary states what is to be achieved and leaves how to the AI:

@pathfind:FUNC
>>> Produce a pathfinding algorithm with O(n log n) worst-case complexity.
>>> The AI is free to choose the algorithmic family.

An imperative boundary fixes both:

@pathfind:FUNC
>>> Use Dijkstra's algorithm with a binary heap implementation.
>>> The AI must follow the prescribed approach.

The same author can mix both within a single program. Some modules are fixed and audited; others are exploratory. The dial sits inside the contract, not at the language level — and never reaches "fully manual" or "fully delegated." That's deliberate: Anglish is the meeting place, not a spectrum end-to-end.

Two coupled loops.

The contract is enforced through two loops working in tandem:

• The refinement loop connects the human author and the AI author. Solutions are proposed, reviewed, and improved against the contract.
• The enforcement loop connects the compiler and the runtime. Outputs are validated against the declared boundaries, tested, and adapted for runtime conditions.

Together they turn human–AI programming from an unbounded collaboration into a controlled, tunable process.

What you keep, what you give up.

You keep natural-language ergonomics: vibe blocks carry your intent in plain English. You keep speed: the contract is small — five meta-characters, a handful of type tags. You keep creativity: declarative boundaries leave the AI room to surprise you.

You give up cycle-accurate control. Anglish does not address bytes, registers, or branches. It is not a replacement for systems languages, and it is not trying to be. If you need that level, write that.

For everything else — the long tail of programs that exist to coordinate spaces, agents, tasks, data, and humans — Anglish is the language that meets you and your AI in the middle.

Take the tour → · Read the reference · Read the paper