Clause: an intent compiler for AI-assisted software.
Clause is an experimental framework for building software with AI doing much of the writing, without losing control of the design. It lowers human intent through structured, checkable artifacts until code can be written, reviewed, and repaired against what it was meant to satisfy.
05.1 / what it is
05.2 / why now
AI can write code faster than humans can manually preserve the meaning of those changes. The hard question is no longer only “can the code be generated?” It is whether the code still realizes the architecture, assumptions, invariants, and decisions that gave the system meaning.
The danger is drift. A change can look reasonable by itself and still quietly break an assumption made somewhere else. One session adds a small mismatch. The next adds another. After enough sessions, the system may still run, and the code may still look plausible, but the design has started to dissolve.
The obvious answer is to review everything more carefully. But that does not scale. Not having to read every line yourself is one of the reasons to use AI in the first place.
05.3 / the key move
05.4 / why boundaries matter
For automatic context to work, the system must be able to lift out the right pieces cleanly. That means every important piece of meaning needs a clear start and a clear end.
A marker that only says “look here” is useful for navigation, but it is not enough for context. It points to a place; it does not say what content belongs to that place.
Clause therefore treats important definitions, commitments, rules, and design entities as bounded repository artifacts. If something may need to be handed to an AI, the system must know exactly where it begins and exactly where it ends.
This is the small mechanical rule that makes the larger loop possible.
05.5 / artifact chain
Intent
What the system is meant to do and why it matters.
Design
How the system is shaped into entities, rules, and relationships.
Contract
The commitments a specific code unit must satisfy.
Code
The implementation, carrying a trace to what it realizes.
Evidence
Tests, static checks, validation records, or review results.
05.6 / the loop
| Layer | What it does | Why it matters |
|---|---|---|
| Writer | Produces the next artifact or code change from the level above. | The writer works inside a bounded context instead of inventing the architecture from chat memory. |
| Mechanical checker | Catches failures with definite answers: broken links, missing pieces, malformed markers, unresolved references, structural gaps. | Anything deterministic should be checked by a tool, not remembered by a person. |
| Independent reviewer | Judges what a machine cannot decide: whether the change really satisfies the intent. | The reviewer sees the contract and the change, not the writer's self-justification. |
| Person | Directs the system, resolves judgment calls, and shapes the architecture. | Clause does not remove human design judgment. It moves the person upward. |
05.7 / neighboring categories
| Neighboring category | What it does | How Clause differs |
|---|---|---|
| AI coding agents | Generate or modify code. | Clause gives agents bounded contracts and surrounding intent, so generated code remains answerable to the design. |
| AI code review tools | Review diffs and enforce rules. | Clause makes the relevant intent and contracts first-class repository artifacts before the diff reaches review. |
| RAG / semantic retrieval | Find likely relevant context through search or similarity. | Clause aims for computed context: graph traversal over explicit relationships, not guessed relevance. |
| Spec-driven tools | Create specs or plans before implementation. | Clause emphasizes traceability through implementation and later edits, not only planning before code exists. |
| Formal methods | Prove specific properties. | Clause tracks where commitments come from, how they are realized, and which tests, checks, or reviews currently support them. |
05.8 / current status
05.9 / relationship to Yoav's work
Clause grew out of Yoav Fekete's work with complex robotics software and AI-assisted development. The practical problem was not that LLM agents were useless; it was the opposite. They became useful enough to accelerate implementation, and powerful enough to blur architecture, erase design commitments, or turn long-term intent into disposable chat context.
In the broader narrative of this site, Clause is one way of making a problem take the right form. It represents software intent as repository artifacts that humans, agents, and deterministic tools can inspect, address, and check. That keeps Clause connected to Yoav's wider work in structured systems without collapsing Clause into the person, the robotics domain, or any single coding tool.