What if AI-native programming could evolve understanding—not just generate outputs?
We have moved from prompt engineering to context engineering. We are learning to give AI better instructions, stronger references, clearer constraints, and more relevant tools.
That improves the starting point. But a deeper question remains:
What happens to the understanding developed along the way?
When we ask an AI to explain a system, investigate a domain, or design software, we often get an excellent answer. Then the next interaction starts with another prompt. Insights, relationships, corrections, sources, and unresolved questions are easily flattened into a transcript—or lost.
What if those were part of the programming model itself?
Introducing ZOAT
ZOAT — LLM-Native. Ruby-Powered. Intent-Driven. Grounded in HOLOFLUX.
ZOAT is an experimental semantic language for Intent-Oriented Programming (IOP). It explores a different unit of work: not merely the prompt, the specification, or the generated artifact, but the evolving relationship between intention, understanding, and realization.
Its guiding idea is simple:
Intention orients. Understanding evolves. Coherent realization expresses.
ZOAT explores how meaning can be investigated, qualified, preserved, reused, and expressed across domains. HOLOFLUX provides a complementary relational perspective on the unfolding between implicit understanding and explicit expression—not an additional execution phase.
A glimpse of ZOAT Interactive
Consider a modest goal: understand Ruby’s object model. Instead of treating every response as isolated, we can describe a candidate Implicated Order, examine it, request deeper inquiry, and express the current understanding.
# Create or recover an Implicated Order
implicated :ruby, show: true
# Focus on an intention-specific question
understand @ruby, focus: :object_model
# Investigate only where further understanding is justified
deep_understand @ruby,
evaluate: :evolution,
show: true
# Inspect the basis and the change
reflection :evidence
reflection :evolution
# Propose a consolidated representation of the same order
explicated @ruby, show: true
# Express the qualified understanding
explicate :understanding,
as: :explanation
This is experimental, Ruby-shaped conversational notation, not a claim of a validated parser, autonomous runtime, automatic source retrieval, or persistent storage.
What’s different here?
An Implicated Order is conceived as a reusable coherent whole: identity, intention, context, meaningful relationships, evidence, provenance, uncertainties, and possible expressions. It is not simply a longer prompt.
Deep Understanding is not a command to make the answer longer. It asks whether a relevant gap can be investigated and whether evidence actually supports a change. An evolution review can find improvement, no change, regression, or insufficient evidence.
Explicated proposes a consolidated, inspectable representation of the same implicated whole. Explicate, by contrast, asks for a chosen outward expression—such as an explanation, diagram, documentation, or another artifact. These are distinct intentions.
The aim is not to force a pipeline. Understanding should deepen when the intention calls for it, and stop when further inquiry is unjustified.
Beyond better prompts
Context engineering asks: What does the model need to know to do this well?
ZOAT adds another research question: How can qualified understanding evolve, remain coherent, and inform what we realize next?
That is a design direction, not a benchmark result. ZOAT remains an experimental project; its proposed semantic constructs must be distinguished from independently verified runtime capabilities. This is an invitation to explore the model, examine the evidence, and improve the questions.
The next step in AI-native engineering may not be only better generation. It may be better continuity of understanding.
Explore the projects
Zoatworks — Turning Complexity into Understanding.