Human world Machine world meaning structure intent validation natural language ⇄ deterministic model flexibility execution ambiguity strictness
Most software interfaces ask one side to adapt to the other. Humans fill forms, learn syntax, or work with representations designed for machines. Machines increasingly try the opposite: they infer human intent from natural, unstructured text.
Both approaches are useful, but neither fully solves the boundary problem.
The missing middle
There is another possibility: a representation that belongs completely to neither side. It can stay natural enough for a person to read and edit, while remaining strict enough for software to parse, validate, transform, and build without guessing.
The goal is to create a shared representation where both can meet.
This is one of the ideas behind Text2Doc (T2D): a textual representation that remains natural enough for people to read and edit, while being explicit enough for deterministic tools to parse, validate, and process.
Human-readable and machine-validatable
Human-readable and machine-readable do not have to be opposites. The difficult part is finding a small set of clear rules that people can understand without turning the source into a machine serialization format.
| Human needs | Machine needs |
|---|---|
| Readable narrative | Deterministic grammar |
| Simple authoring | Explicit structure |
| Meaningful organization | Validation |
| Freedom from layout noise | Stable transformation rules |
| Easy review and version control | Reproducible processing |
When a representation works for both sides, it becomes more than a file format. It becomes a contract between human intent and machine execution.
LLMs change the boundary
Large language models make this boundary more interesting. They work surprisingly well with the language people already use. They can read prose, reorganize information, suggest structure, explain content, and transform documents from natural-language instructions.
But an LLM is probabilistic. It can produce excellent results, yet it cannot give the same guarantees as a parser, validator, compiler, or build system.
Human ←→ T2D ←→ LLM
↕
deterministic tools
The important point is that the LLM does not need to become the trusted core. It can work through the same explicit representation used by the human and the deterministic tools.
Probabilistic intelligence, deterministic correctness
An LLM can propose a document, rewrite a section, infer an outline, or reconstruct structure from imperfect source material. The result can then pass through a deterministic parser and validator.
Human request
↓
LLM proposes or edits
↓
T2D
↓
parser
↓
validator
↓
VALID / INVALID
↓
deterministic build
This separates two different responsibilities. Intelligence may remain flexible and probabilistic. Correctness remains an engineering property of the deterministic toolchain.
T2D as a communication container
This suggests another role for T2D: not only a document source format, but a communication container between a person and an LLM. Instead of repeatedly exchanging unstructured or complex document content, both can work through the same constrained textual representation. Human intent and machine-assisted changes meet in a form that remains readable, explicit, and ready for deterministic validation.
Human
↓
T2D
↓
LLM
↓
modified T2D
↓
Text2Doc validator
↓
deterministic rendering
The LLM can focus on meaning and transformation. Text2Doc can focus on parsing, structural validity, project semantics, and reproducible output. A human can inspect the same source before and after the change.
Beyond documents
The same boundary appears outside documentation. Systems engineering also begins with human ideas, decisions, and intent, while machines need explicit structure. This is the motivation behind Text2System (T2S): to describe architecture and engineering contracts in a form people can understand and deterministic tools can analyze.
| Domain | Shared representation | Purpose |
|---|---|---|
| Documents | T2D | Human narrative ↔ deterministic document processing |
| Systems engineering | T2S | Engineering intent ↔ explicit system model |
The common idea is not a particular syntax. It is the attempt to connect different worlds through a representation that is understandable on both sides and mechanically validatable.
A shared meeting point
AI gives us increasingly capable interpreters of human intent. Deterministic tools give us reliability, validation, repeatability, and execution. Neither replaces the other.
The interesting question is what should live between them.
a representation simple enough for humans and LLMs to understand, but explicit enough for deterministic tools to validate.
If that boundary is designed well, the representation becomes a stable meeting point. Humans can express intent. LLMs can help with interpretation and transformation. Deterministic tools can validate and execute. Each participant can do what it does well, without pretending to be the others.