tiempo de lectura : 20 minutes

La ingeniería de prompts es frágil. A 80 000 tokens, tus reglas de alineación se pierden en el ruido, y el LLM olvida lo que le pediste al comienzo de la conversación. Mi solución? No alinear por el texto, sino por l'espacio. He estructurado mi espacio de trabajo de desarrollo en cuatro círculos de confianza concéntricos — del jardín secreto íntimo hasta las forjas públicas — y cada círculo es una zona física del sistema de archivos. El LLM no necesita que le recuerden las reglas: el camino del archivo las contiene. Así es como funciona, y por qué esta arquitectura de alineación por el espacio es más resiliente que un`system prompt`de 500 líneas.

Es un artículo largo.
Instálese cómodamente.

toc

[]

La constatación: la ingeniería de prompts es un castillo de arena

Durante tres semanas, desarrollé plugins Gradle con Opencode, utilizando tres LLMs diferentes — Kimi K2.6, GLM-5.1 y DeepSeek-V4-Pro (el único sobreviviente, pero esa es otra historiaYa cubierta aquí. Mi método de gobernanza de agente Lo he documentado en detalle en un artículo anterior. se basa en archivos AsciiDoc —AGENT.adoc, INDEX.adoc, PROMPT_REPRISE.adoc— que cargan aproximadamente 30 000 tokens de reglas, backlog e historial al inicio de cada sesión.

Y pese a esta infraestructura documental, dos cosas me llamaron la atención:

  1. El LLM olvida. Incluso con las reglas absolutas en la parte superior de cada archivo EAGER, más allá de 60 000 tokens acumulados (contexto inicial + conversación), Kimi K2.6 ha empezado a ofrecer`Write`aplastantes en archivos de configuración. GLM-5.1 confundió un token de Firebase con un placeholder que debía reemplazarse. Las reglas estaban escritas — el LLM ya no las veía.

  2. La gobernanza misma se convierte en un problema. Después de haber implementado el mecanismo Hot/Warm/ColdArtículo sobre la rotación de backup. para evitar la explosión del contexto, mis archivos EAGER todavía pesaban 1414 líneasHe documentado esta auditoría aquí. La gobernanza — diseñada para proteger al LLM de la saturación — saturaba al LLM.

Necesitaba un mecanismo de alineación que no dependiera del número de tokens en el prompt.

La respuesta: dejar de alinear por el texto y comenzar a alinear por l'espacio.

Los Cuatro Círculos de Confianza: una Ontología Espacial

Mi expediente`workspace/(dentro~/workspace/`) no es un repositorio Git. Es la raíz de todo mi trabajo — código, documentación, formación, infraestructura. Y está estructurado en cuatro zonas que no son convenciones de organización, perocírculos de confianza concéntricos:

nivel

Etiqueta

Zona física

CVS

Visibilidad

0

Jardín secreto

`workspace/`raíz

Ninguno

Íntimo — pensamiento libre, sin commit, sin publicación

1

caja fuerte

configuration/

Git privado (solo)

Secretos, tokens, archivo de visión. Una sola persona.

2

Biblioteca

office/

Git privado (ampliado)

Dato pedagógico, SPG/SPD, esquemas JSON. Círculo de confianza identificado.

4

Forges (públicas)

foundry/

Git público (Apache 2.0)

Código fuente, plugins, pruebas, documentación técnica.

NOTA: No hay nivel 3 en la tabla. El nivel 3 es un nivel transitorio: es contenido de`office/`que ha sido anonimizado y está listo para ser publicado como datos abiertos. No tiene una zona física propia — es un estado de los datos, no una ubicación.

Cada nivel responde a una pregunta precisa:

  • ¿Dónde depositar una idea que aún no está lista para ser compartida, incluso con un círculo reducido? → El jardín secreto. Sin Git. Sin presión.

  • ¿Dónde almacenar un token API sin que se filtre? → Caja fuerte`configuration/`). Físicamente aislado. Ningún otro depósito puede referenciarlo por error.

  • ¿Dónde co-construir un catálogo de formación con un OF piloto? → La biblioteca`office/`). Versionado, colaborativo, pero privado.

  • ¿Dónde industrializar un plugin Gradle de código abierto? → Las forjas`foundry/`). Público, bifurcable, probado en CI.

Esta ontología esconsumible por un LLM. Cuando lee un archivo en`foundry/plantuml-gradle/src/`, lo sabe implícitamente: "estoy en el círculo 4 — código público, pruebas obligatorias, sin secretos, sin datos pedagógicos". No necesita un recordatorio que se lo recuerde.

El Jardín Secreto: el Espacio fuera de CVS

Es el concepto más importante — y el más contraintuitivo.

la raíz`workspace/no tiene.git/. Los documentos que viven allí (`WORKSPACE_VISION.adoc, WORKSPACE_AS_PRODUCT.adoc, WORKSPACE_ORGANIZATION.adoc— y el que estás leyendo ahora mismo, que proviene de ello) no están destinados a ser versionados, compartidos, o incluso leídos por otra persona que yo. Son depensamientos en germinación.

El jardín secreto es out-of-CVS por naturaleza. La ausencia de versionado es la condición de la libertad de pensar. No se escribe allí para ser leído — se escribe allí para aclarar la propia visión.

Pero esta libertad tiene un costo: un`rm`accidental, y son meses de reflexión estratégica que desaparecen. La solución no es de versionar el jardín (eso sería destruirlo) — es de loespejaren el círculo más restringido.

El .gitignore como Configuración de Gobernanza

En la raíz de`workspace/, un archivo.gitignore`mínimo declara lapolítica de historicizaciónde los archivos del jardín secreto :

.goosehints
.goose

Ce .gitignore`no tiene una función Git clásica (no hay.git/`a la raíz). Él actúa como unarchivo de configuración de gobernanzaque responde a una pregunta específica: qué artefactos del jardín secreto merecen ser historicizados, y cuáles son puramente transitorios?

  • Los archivos listados en`.gitignore`—.goosehints, .goose— son artefactos efímeros generados por los agentes. Sin valor stratégique. Sin historicización.

  • Los archivos`.adoc`de la raíz —WORKSPACE_VISION.adoc, WORKSPACE_ORGANIZATION.adoc, WORKSPACE_AS_PRODUCT.adoc, WHAT_THE_GAMES_BEEN_MISSING.adoc, depots_implementes_strategie.adoc, synthese-LLMs-long-contexte.adoc— no sonpasoen el`.gitignore`. Estos son los artefactos a historicizar.

Le `.gitignore`es elesquema de gobernanza: todo lo que no esté listado allí es un candidato al snapshot. Y el LLM, al leer este archivo, sabe exactamente qué debe archivarse y qué puede ignorarse — sin necesidad de recordárselo en un prompt.

El Mecanismo de Snapshot

He creado`configuration/vision-archive/: unas instantáneas fechadas de todos los.adoc`de la raíz, commits en el repositorio privado`configuration/`. Cada sesión de lluvia de ideas produce una instantánea:

DATE=$(date +%Y-%m-%d)
mkdir -p /home/cheroliv/workspace/configuration/vision-archive/$DATE
cp /home/cheroliv/workspace/*.adoc /home/cheroliv/workspace/configuration/vision-archive/$DATE/
cd /home/cheroliv/workspace/configuration && git add vision-archive/ && \
  git commit -m "vision-archive: snapshot $DATE"

El procedimiento se dispara al final de la sesión por el LLM mismo, que ejecuta esta tarea global de enrutamiento. Cada instantánea captura el estado completo del pensamiento estratégico en un momento T.

El historial de Git de`configuration/`se convierte en labiografía de mi pensamiento estratégico. Puedo hacer un`git log — vision-archive/`y ver la evolución de mi visión, sesión por sesión, fecha por fecha

Ejemplo real del historial después de un día de trabajo :

$ git -C configuration log --oneline -- vision-archive/
1089d1b vision-archive: fin de session finale 2026-05-03
6b21eaf vision-archive: fin de session 2026-05-03-1300
1690f82 vision-archive: post-article 2026-05-03
28e6593 vision-archive: post-migration 2026-05-03
3707b78 vision-archive: snapshot 2026-05-03 — jardin secret initial

Cinco instantáneas en un día. Cada uno es un punto de restauración. Cada uno es un hito en la génesis de la estrategia.

El expediente`configuration/vision-archive/latest/`contiene permanentemente unacopia de trabajodel último snapshot, que sirve como referencia rápida sin necesidad de navegar por el historial de Git.

Y para el LLM, es unoráculo de coherencia: cuando observa una contradicción entre la implementación actual y la visión archivada en una fecha anterior, puede señalarla.

El Cofre-Fuerte: configuration/ como Spring Cloud Config

`configuration/`No contiene solo el archivo de la visión. Su función principal — y futura — es ser unservidor Spring Cloud Config. Todos los secretos, tokens, credenciales y descriptores de infraestructura viven aquí, en un repositorio Git privado accesible únicamente por el propietario.

¿Por qué un repositorio separado en lugar de un archivo?.env¿en cada proyecto?

  • Push accidental de un secreto : imposible. Los secretos están en un repositorio privado que los proyectos públicos no pueden referenciar por error.

  • Auditoría: el historial de Git proporciona el rastro de cada modificación de configuración. quien cambió qué, cuando, con qué hash SHA.

  • Rollback :`git revert`sur una configuración dañada. Instantánea, sin backup manual.

La Biblioteca : office/ como Data Consumible

`office/`es el correspondiente documental del trabajo de desarrollo. Contiene los artículos de blog, las especificaciones técnicas, los materiales de formación (38 directorios de cursos FPA, SPG/SPD, esquemas JSON, taxonomías Bloom/Harrow/Krathwohl) — todo lo que constituye elmaterial pedagógico.

Pero`office/`No es solo un cajón de docs. Es unafuente de datos estructuradaque los plugins Gradle de`foundry/`consumen. Un artículo de blog en`office/`es una entrada que un plugin transformará en HTML. Un SPG AsciiDoc en`office/metiers/FPA/`es un artefacto que un orquestador parseará para generar diapositivas, cuestionarios y cápsulas de video.

Et le `build.gradle.kts`en la raíz de`office/`no es del código de negocio — es unoscript de consumo del ecosistema de plugins. Él dice: "aquí están los plugins de Gradle que utilizo, aquí está el contexto de mi espacio de trabajo

Las Forjas : foundry/ como Implementación

foundry/`contiene elcódigo industrializado. 54 repositorios Git, de los cuales 7 actualmente gobernados por los.agents/`. Aquí es donde la visión se vuelve ejecutable — plugins Gradle, CI/CD, pruebas JUnit5 + Cucumber.

La relación con`office/`es bidireccional:

  • office/→foundry/: los datos pedagógicos son la materia prima que los plugins consumen.

  • foundry/→office/: los plugins producen datos que enriquecen`office/` — le `graph.json`de graphify-gradle, los decks slider compilados, los informes de compilación

Pros/Contras : Alineamiento Espacial vs Alineamiento por Prompt

Comparemos los dos enfoques.

Enfoque Clásico : A lineación por Pre-Prompt

✅ Pro

�❌ Contra

Fácil de implementar. Un bloque de texto en el system prompt.

Frágil al contexto largo : la regla se pierde después de 80K tokens.

Funciona para reglas generales (tono, formato).

No verificable : nada impide que el LLM viole la regla.

No es necesario repensar la arquitectura del proyecto.

No transferible : cada repositorio redeclara las reglas.

Declarativo puro: el LLM sabe que debería, pero nada le impide.

Este Enfoque: Alineación por Ontología Espacial

✅ Pro

�❌ Contra

Resiliente al contexto largo : la regla está en la ruta del archivo, no en un prompt distante.

Costo de infraestructura inicial : estructurar el workspace en círculos lleva tiempo.

verificable mecánicamente : un secreto en`foundry/es detectable por`git check-ignore.

Requiere disciplina : un nuevo contribuidor debe entender los círculos.

Transferible : un`AGENT.adoc`estándar expone los círculos a cualquier nuevo proyecto.

Solo cubre las restricciones espaciales — el estilo de código permanece en el prompt.

Seguridad por diseño : uno`git push`desde`foundry/no puede exponer`configuration/.

Consumible por agentes no LLM : un orquestrador Gradle puede enrutar según el círculo.

El beneficio principal no es defensivo (seguridad, visibilidad) — escreativo. Cuando el LLM trabaja en un espacio estructurado por una ontología, puede hacer lo que ningún prompt le permite: observar el delta.

La Álgebra Relacional del Workspace y el Delta Observable

Cuando el LLM recorre`foundry/, él tiene unmalla de datos estructurados: nodos (plugins, archivos, pruebas, dependencias), aristas tipadas (`import, depends_on, generates, tests), relaciones de composición y orden (`training-gradle`extraer el repositorio →`slider-gradle`genera las diapositivas →`capsule-gradle`reproduce el video)

Esta álgebra no está escrita en ninguna parte de forma clara — pero es observable. Cada`build.gradle.kts`expone las dependencias. Cada`INDEX.adoc`expone referencias cruzadas.

El LLM observa este álgebra y detecta eldelta: la brecha entre lo que el sistema ya sabe producir y lo que la visión describe.

A partir de este delta, puede definircartografías de expertos en oficios— CDA (Diseñador desarrollador de aplicaciones, Kotlin/Gradle/JHipster) y FPA (Formador profesional de adultos, Pedagogía/Qualiopi/Bloom) — e identificar lo que falta para cada experto.

Expert CDA (Kotlin/Gradle/JHipster)
  ├── Plugins : jhipster-gradle-plugins, plantuml-gradle,
  │   codebase-gradle
  ├── Delta : pas encore de SPG CDA formalisé,
  │   pas de fine-tuning expert CDA

Expert FPA (Pédagogie/Qualiopi/Bloom)
  ├── Plugins : training-gradle, slider-gradle,
  │   school-backoffice/forms, capsule-gradle
  ├── Matériel : 38 modules cours, SPG/SPD, taxonomies
  └── Delta : parser AsciiDoc→JSON à créer,
      orchestrateur à coder

El LLM no necesita que le digan qué hacer. El delta emerge de la estructura.

El Vector Compuesto de Contexto: RAG + pgvector + Graphify

El álgebra relacional no es una construcción teórica. Está materializada por tres componentes que forman unvector compuesto de contextopara el LLM.

Componente 1 — RAG LangChain4j + PostgreSQL pgvector

Ya tengo LangChain4j en producción en dos plugins :`slider-gradle`(4 proveedores LLM) y`plantuml-gradle`(7 proveedores). Los embeddings ONNX (AllMiniLmL6V2) indexan los datos de`office/`y el código fuente de`foundry/`en PostgreSQL + pgvector.

Este RAG opera en dos dimensiones :

  • Dimension data : los documentos`office/`(SPG, artículos, formaciones, esquemas JSON)

  • Dimension code : las bases de código`foundry/`(fuentes Kotlin, pruebas Cucumber, AGENT.adoc)

La intersección cubre tanto el qué (el dominio del negocio) como el cómo (la implementación).

Componente 2 — Knowledge Graph Graphify

Graphify está integrado en`plantuml-gradle`(109 tests, 380/380 PASS) y produce un`graph.json`— un knowledge graph estructurado con nodos, aristas y comunidades detectadas automáticamente.

A diferencia del RAG que opera por similitud vectorial (difuso), el knowledge graph opera porrelaciones exactas(determinista) :`graphify query`para las consultas semánticas (~50 tokens)`graphify path`para navegar`graphify explain`para explicar.

Componente 3 — Graphify incremental : Disperso, Agregable, Consumible

Es la decisión arquitectónica clave.

Graphify no debe vivir en un único repositorio. Debe vivir de maneradispersoen cada plugin:

  1. Cada plugin incorpora una tarea Gradle`updateKnowledgeGraph`que llama a Graphifyen su propio alcancey produce un`graph.json`local.

  2. El script de compilación de`office/ consume`graphify-gradle`con`rootDir = /home/cheroliv/workspace`y produce un`graph.json globalque agrega los grafos locales.

  3. El RAG de cada plugin inyecta el`graph.json`global comofiltro de contextopara las consultas LLM.

TÂCHE GRADLE (dans chaque plugin)
    ↓
graphify → graph.json (scope local)
    ↓
office/build.gradle.kts → graph.json (scope global)
    ↓
RAG pgvector (dans slider, plantuml, codebase...)
    ↓  ← injection du graph.json comme filtre
LLM (deepseek-v4-pro)
    ↓  ← observation algèbre relationnelle
    ↓  ← détection delta vs cartographies experts
PRIORISATION → prochaine tâche

Resultado: el LLM no busca en el vacío — se desplaza en un espacio estructurado por el knowledge graph. Una consulta sobre "génère un diagramme" sabe alcanzar los nodos pertinentes del grafo.

Clasificación RGPD Automática : el LLM como Enrutador

La ontología espacial no se limita a alinear el LLM — le da unacuadro de clasificación RGPDpara enrutar cada dato hacia su zona legítima

Criterio

Detección LLM

Acción

Nivel máximo

Dato personal (nombre, correo electrónico, IP)

patrón`@`, IP, nombres propios

Anonimizar →`[OF_PILOTE]`o router de nivel 2

2

Token / Secreto / Credencial

Patrón`sk-…​, `ghp_…​, ya29…​

Enrutador →configuration/. Referenciar por`${VAR}`en el código.

1

URL interna

Contiene`localhost`, IP privada

Anonimizar →${API_URL}

2

Dato pedagógico (SPG, curso)

Estructura Bloom/Qualiopi

Enrutador →office/(nivel 2). Versión doble si exporta.

3

Código fuente / prueba

Extensión`.kt`, .kts`dentro`foundry/

Router →foundry/. Verificar ausencia de secretos.

4

Al final de la sesión, el LLM ejecuta unatarea global</think>

  1. Lectura del`.gitignore`raíz para identificar los artefactos efímeros (para excluir del snapshot) vs los artefactos estratégicos (para historizar)

  2. Inventario de todos los archivos`.adoc`de la raíz`workspace/`

  3. Filtrado: exclusión de los archivos enumerados en`.gitignore`, inclusión de todos los demás

  4. Copia en`configuration/vision-archive/$DATE/y actualización del symlink`latest/

  5. Commit en el repositorio`configuration/`con un mensaje estructurado

  6. Clasificación automática RGPD de cada archivo modificado (todos los círculos)

  7. Enrutamiento: datos`office/→ commit privado, código`foundry/→./gradlew check, configuración → commit

  8. Informe estructurado con alertas RGPD y confirmación de archivaje

Le `.gitignore`raíz no es un archivo de configuración de Git — es unarchivo de gobernanza de la historicización. Define el esquema que el LLM consume para decidir qué archivos del jardín secreto entran en la biografía estratégica y cuáles son descartables.

El LLM ya no es un simple generador de texto. Él es elgestor de informacióndel ecosistema — productor, clasificador, enrutador.

Roadmap : desde AsciiDoc hasta LangGraph4j

Hoy, esta gobernanza es determinista : el LLM aplica un procedimiento descrito en archivos AsciiDoc. Es lafase 1— la ingeniería de prompts con memoria LLM.

La fase 2extraerá cada paso del procedimiento en unatarea Gradle tipada:

./gradlew endSessionWorkspace    → snapshot vision-archive
./gradlew endSessionProject      → archive .agents/
./gradlew endSessionReport       → rapport multi-zones

La fase 3modelará el proceso de fin de sesión como ungrafo de estadoconhttps://github.com/langgraph4j/langgraph4j[LangGraph4j] :

[Start] → [Inventaire fichiers modifiés]
       → [Classification RGPD] (nœud ONNX)
       → [Branchement par cercle]
            ├→ cercle 0 → snapshot → commit
            ├→ cercle 2 → anonymisation → commit
            ├→ cercle 4 → archive → commit
            └→ cercle 1 → commit configuration/
       → [Rapport] → [End]

Este grafo será versionado en la CI/CD, ejecutado por Gradle, configurado a través de los GitHub Secrets de los plugins. El LLM ya no tendrá que decidir el enrutamiento — el grafo lo hará.

Lo que esta arquitectura resuelve (y lo que no resuelve)

La ontología espacial no cubre todo. Las convenciones de estilo de código, el nombre, las decisiones de diseño arquitectónico — todo eso permanece en el prompt. Lo que resuelve la ontología espacial escapa de seguridad y visibilidaddonde cada octeto debe vivir, y quién puede verlo.

Esto es lo que aporta concretamente:

  1. No`git push`accidental de un secreto: los secretos están en`configuration/(círculo 1). Los proyectos públicos están en`foundry/(círculo 4). Ningún camino cruza los dos.

  2. No hay código de negocio en los datos :`office/contiene de.adoc`, de YAML, de esquemas JSON — pero no de`.kt`. Le `build.gradle.kts`quien vive allí es un script de consumo, no código de negocio.

  3. Sin pensamiento estratégico expuesto : los documentos de visión viven en el jardín secreto (raíz fuera-CVS). Los snapshots están en`configuration/`(cofre fuerte privado). Nadie, incluso en un círculo de confianza ampliado, lee el origen de la estrategia.

  4. Auto-priorización: El LLM observa el delta entre el álgebra relacional (lo que existe) y los mapas de expertos (lo que es necesario). La próxima tarea de desarrollo surge de este delta.

Conclusión: la arquitectura como discurso

No pongo un manifiesto político en el footer de mi sitio. No pongo normas éticas en mis prompts. La alineación no está en el texto — está en elsistema de archivos.

Cuando un LLM trabaja en este espacio, no puede filtrar un secreto (el camino se lo impide). No puede confundir un dato pedagógico con código fuente (el área física es diferente). No puede olvidar una regla de seguridad de 80 000 tokens — porque la regla no está en el prompt, está en el`workspace/` → configuration/→office/(output nothing)`foundry/`que cada lectura de archivo sea reactiva

Es el principio de secure by design aplicado al alineamiento del agente: no pedir al LLM que recuerde las reglas. Hacer que la arquitectura haga que el error sea estructuralmente imposible.

Así que, de paso, le da al LLM lo que ningún prompt puede darle: la capacidad depercibirdónde está, lo que existe, lo que falta — y deducir de ello lo que debe hacer.

Referencias

Articles connexes