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 only survivor, but that’s another storyAlready covered here.). My agent governance methodI documented it in detail in a previous article. relies on AsciiDoc files —AGENT.adoc, INDEX.adoc, PROMPT_REPRISE.adoc— which load ~30,000 tokens of rules, backlog, and history at the start of every 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 byspace.

My`workspace/folder (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 just storage conventions, butconcentric circles of trust:

Each level answers a specific question:

This ontology isconsumable by an LLM. When it reads a file in`foundry/plantuml-gradle/src/`, it knows implicitly: "I am in circle 4 — public code, mandatory tests, no secrets, no pedagogical data". It does not need a prompt to remind it.

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`assembles the video).

This algebra is written nowhere in plain text — but it is observable. Every`build.gradle.kts`exposes dependencies. Every`INDEX.adoc`exposes cross-references.

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

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

The LLM does not need to be told what to do. The delta emerges from the structure.

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

Spatial ontology doesn’t just align the LLM — it gives it aGDPR classification gridto route each piece of data to its legitimate zone.

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

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

The LLM is no longer a simple 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. This isphase 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, and configured via plugin GitHub Secrets. The LLM will no longer have to decide the routing — the graph will do it.

Here is what it brings concretely:

I don’t put a political manifesto in my site’s footer. 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 pedagogical data 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 every file read reactivates.

This is the principle of secure by design applied to agent alignment: do not ask the LLM to remember the rules. Make the architecture render the error structurally impossible.

And in the process, it gives the LLM something no prompt can: the ability toperceivewhere it is, what exists, what is missing — and deduce what it must do.