The Developer's Secret Garden: How Spatial Ontology Aligns LLMs Without Prompt Engineering

For three weeks, I developed Gradle plugins with Opencode, using three different LLMs — Kimi K2.6, GLM-5.1, and DeepSeek-V4-Pro (the sole survivor, but that’s another storyAlready covered here.) My agent governance methodI documented it in detail in a previous article. is based on AsciiDoc files —AGENT.adoc, INDEX.adoc, PROMPT_REPRISE.adoc— which load ~30 000 tokens of rules, backlog, and history at the start of each session.

And despite this documentary infrastructure, two things struck me:

I needed an alignment mechanism that did not depend on the number of tokens in the prompt.

The answer: stop aligning by text, and start aligning by thespace.

My file`workspace/(in~/workspace/`) is not a Git repository. It is the root of all my work — code, documentation, training, infrastructure. And it is structured into four zones that are not storage conventions, butconcentric circles of trust:

Each level answers a specific question:

This ontology isconsumable by an LLM. When he reads a file in`foundry/plantuml-gradle/src/`, he implicitly knows: "I am in circle 4 — public code, mandatory tests, no secrets, no educational data". He does not need a prompt reminding him of that.

Let’s compare the two approaches.

When the LLM traverses`foundry/, it has astructured data lattice: nodes (plugins, files, tests, dependencies), typed edges (`import, depends_on, generates, tests), composition and order relations (`training-gradle`extracts the repository`slider-gradle`generates the slides →`capsule-gradle`edit the video)

This algebra is not written anywhere in plain — but it is observable. Each`build.gradle.kts`exposes dependencies. Each`INDEX.adoc`exposes cross-references.

The LLM observes this algebra and detects thedeltaThe gap between what the system already knows how to produce and what the vision describes.

From this delta, it can define somebusiness expert mappings— CDA (Application Designer/Developer, Kotlin/Gradle/JHipster) and FPA (Professional Adult Trainer, Pedagogy/Qualiopi/Bloom) — and identify what is missing for each expert.

The LLM doesn’t need to be told what to do. The delta emerges from the structure.

Relational algebra is not a theoretical construct. It is materialized by three components that form acomposite context vectorfor the LLM.

The spatial ontology does not merely align the LLM — it gives it aGDPR classification gridto route each data item to its legitimate zone

At the end of the session, the LLM executes aglobal task:

Le `.gitignore`root is not a Git configuration file — it’s ahistorization governance file. It defines the schema that the LLM consumes to decide which files from the secret garden go into the strategic biography and which are disposable.

The LLM is no longer just a text generator. It is theinformation managerof the ecosystem — producer, classifier, router.

Today, this governance is deterministic: the LLM applies a procedure described in AsciiDoc files. It is thephase 1— prompt engineering with LLM memory.

La phase 2will extract each step of the procedure into atyped Gradle task:

La phase 3will model the end-of-session process as astate graphwithhttps://github.com/langgraph4j/langgraph4j[LangGraph4j]:

This graph will be versioned in CI/CD, executed by Gradle, configured via the GitHub Secrets of the plugins. The LLM will no longer have to decide on routing — the graph will do it.

Here is what it concretely brings:

I don’t put a political manifesto in the footer of my site. I don’t put ethical rules in my prompts. Alignment is not in the text — it is in thefile system.

When an LLM works in this space, it cannot leak a secret (the path prevents it). It cannot confuse a teaching datum with source code (the physical zone is different). It cannot forget a security rule at 80,000 tokens — because the rule is not in the prompt, it is in the`workspace/` → configuration/→office/→`foundry/`that each file reading is reactive.

It’s the principle of secure by design applied to agent alignment: do not ask the LLM to remember the rules. Make the architecture such that error is structurally impossible.

And by the way, that gives the LLM something no prompt can give it: the ability toperceivewhere it is, what exists, what is missing — and deduce what it must do.