La semana pasada diagnostiqué la enfermedad: seis herramientas de IA para código, seis formatos propietarios de configuración, cero interoperabilidad. CLAUDE.md invisible para Cursor. .cursor/rules sin sentido para Copilot. Semanas de inteligencia acumulada por tu equipo encerradas dentro del parser de turno que se digne leerlas.

Todas las respuestas a ese artículo coincidieron en que el lock-in es real — y después hicieron la misma pregunta: "¿Y entonces qué hago?" Justo. Diagnosticar una situación de rehenes sin plan de rescate es solo comentario. Acá está el plan de rescate.

Por qué "elegí bien" dejó de ser suficiente

El terreno se movió tres veces solo en la última semana. GitHub congeló todas las suscripciones individuales de Copilot el 20 de abril porque el cómputo de agentes reventó lo que una suscripción plana puede cubrir — el VP de Producto Joe Binder admitió que "los flujos de trabajo agénticos cambiaron fundamentalmente las demandas de cómputo de Copilot". El 15 de abril, Zed lanzó subagentes paralelos y un gateway universal de LLMs. El 14 de abril, Anthropic reconstruyó Claude Code como app de escritorio con Routines activadas desde la nube. OpenAI actualizó su Agents SDK el 15 de abril con ejecución sandboxed e integraciones MCP. Las herramientas mutan semanalmente. Tus reglas no deberían estar atrapadas dentro de la que elegiste hace seis meses.

Ya conocés el problema. Esta guía te da una solución funcional que podés commitear hoy.

La solución: un archivo canónico, cinco copias por vendor

El concepto es ofensivamente simple. Mantené un archivo fuente de verdad en un directorio vendor-neutral. Sincronizalo a cada formato propietario con un script de shell. Nunca edites los archivos de vendor directamente.

Paso 1: Creá .ai/rules.md

Elegí un nombre de directorio que ningún vendor haya reclamado. .ai/ funciona.

.ai/
├── rules.md           # Reglas canónicas del proyecto
├── architecture.md    # Contexto de diseño del sistema
├── patterns.md        # Convenciones de código
└── sync.sh            # El script que te libera

Tu rules.md es Markdown puro:

---
project: my-app
lang: [typescript, python]
updated: 2026-04-21
---

# Project Rules

## Code Style
- Strict TypeScript. No `any`. Nunca.
- Python: Black formatter, líneas de 88 caracteres.
- Todas las funciones llevan docstrings. Sin excepciones.

## Architecture
- Monorepo: apps/ para servicios, packages/ para libs compartidas.
- Rutas de API en `src/routes/`, lógica en `src/services/`.
- Nunca importar entre apps directamente. Usá packages.

## Testing
- Tests unitarios co-ubicados: `foo.ts` → `foo.test.ts`.
- Tests de integración en `__tests__/integration/`.
- Mínimo 80% de branch coverage en services/.

## Deployment
- La rama main hace auto-deploy a staging.
- Producción: aprobación manual + E2E pasando.
- Variables de entorno en Vault, nunca en archivos .env.

## Gotchas
- El servicio de pagos usa el cliente legacy de Stripe v2. No refactorizar — contrato con el vendor.
- Los tipos de GraphQL se generan en build time. Ejecutá `make codegen` después de cambiar el schema.

Fuente de verdad. Cualquier herramienta puede leerlo. Cualquier humano puede leerlo. Sin magia de vendor, solo Markdown.

Paso 2: El script de sincronización

#!/usr/bin/env bash
set -euo pipefail

CANONICAL=".ai/rules.md"
[ ! -f "$CANONICAL" ] && echo "No ${CANONICAL} found." && exit 1

HEADER="# Auto-generated from .ai/rules.md — do not edit directly"
BODY=$(printf '%s\n\n%s' "$HEADER" "$(cat "$CANONICAL")")

echo "$BODY" > CLAUDE.md                                            # Claude Code
mkdir -p .cursor && echo "$BODY" > .cursor/rules                    # Cursor
mkdir -p .github && echo "$BODY" > .github/copilot-instructions.md  # GitHub Copilot
echo "$BODY" > GEMINI.md                                            # Gemini
mkdir -p .windsurf && echo "$BODY" > .windsurf/rules                # Windsurf

echo "Synced to 5 vendor configs."

Veinte líneas. Cinco vendors. Una fuente. Ejecutalo después de cada edición. Ese es todo el truco.

Paso 3: Automatizalo porque no te vas a acordar

Te conocés. Agregá un pre-commit hook:

#!/usr/bin/env bash
# .git/hooks/pre-commit (o husky / lefthook)

if git diff --cached --name-only | grep -q "^\.ai/"; then
  echo "Changes in .ai/ — syncing vendor configs..."
  bash .ai/sync.sh
  git add CLAUDE.md .cursor/rules .github/copilot-instructions.md \
         GEMINI.md .windsurf/rules
fi

Editás el archivo canónico, commiteás, las copias de vendor se actualizan solas. El header # Auto-generated les dice a tus compañeros que no toquen los archivos generados.

Paso 4: Contexto de arquitectura

Las reglas solas no alcanzan. Las herramientas de IA también consumen docs de arquitectura y mapas de componentes. Mismo patrón — guardalos en .ai/, concatenalos durante el sync:

<!-- .ai/architecture.md -->
# System Architecture

## Services
- **api-gateway**: Express.js — auth + routing
- **user-service**: Python/FastAPI — dueño de los datos de usuario
- **payments**: Node.js — integración con Stripe (legacy v2)
- **notifications**: Go — async vía SQS

## Data Flow
Requests → api-gateway → service → su propia DB.
Cross-service: solo eventos SQS. Nunca HTTP directo.

Extendé sync.sh para concatenar rules.md + architecture.md + patterns.md. Claude Code maneja múltiples archivos de contexto nativamente; para las herramientas que no, un solo archivo grande funciona bien.

Lo que no podés hacer portable

Acá es donde los vendors se ganan su lock-in, y donde dejo de pretender que esto lo arregla todo.

Configuraciones de runtime de agentes. Las Routines de Claude Code — agentes en la nube disparados por schedules o eventos de GitHub — no tienen equivalente en Cursor. La orquestación de agentes paralelos de Cursor no funciona como los subagentes de Zed. Son comportamientos de runtime, no contexto estático. Ningún archivo de config los captura porque no son config. Son features de producto que estás alquilando.

Memoria acumulada. Claude Code construye MEMORY.md con el tiempo — un registro de decisiones pasadas, errores, patrones aprendidos. Conocimiento que la IA genera durante el uso, no algo que vos escribís. No lo podés sincronizar porque no existe hasta que la IA lo crea. Cambiás de herramienta, perdés la memoria. Como cambiar de terapeuta y empezar desde la sesión uno, excepto que el terapeuta también se olvidó tu nombre.

Redacción afinada por modelo. "Siempre usá nombres de variables descriptivos" funciona en todos lados. Pero si pasaste semanas afinando reglas para explotar cómo Claude maneja la ambigüedad o esquivar la tendencia de GPT a sobre-abstraer, esos matices no se portan. Diferentes modelos, diferentes mañas, diferentes modos de fallar.

La capa portable cubre aproximadamente el 80% de lo que hace útil a tu herramienta de IA en tu proyecto. El 20% restante es genuinamente específico del vendor. Saber dónde está el límite importa más que pretender que no existe.

CI: no confíes en nadie, especialmente en vos mismo

Agregá detección de drift a tu pipeline:

# .github/workflows/ai-rules-check.yml
name: AI Rules Sync Check
on: [pull_request]
jobs:
  check-sync:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - name: Verify vendor configs match source
        run: |
          bash .ai/sync.sh
          if ! git diff --quiet; then
            echo "Vendor configs drifted from .ai/rules.md"
            git diff --stat
            exit 1
          fi

¿Alguien editó CLAUDE.md a mano? CI mata el PR. Drift eliminado. Una máquina que no le importan tus sentimientos ni tu deadline hace cumplir las reglas.

Por qué ningún vendor va a construir esto por vos

MCP nos dio un protocolo universal para conexiones de herramientas. Nadie hizo lo mismo para el contexto de proyecto. No hay estándar ai-rules.json, no hay spec de interoperabilidad, no hay grupo de trabajo. Cada vendor se beneficia de la incompatibilidad — lock-in accidental que no cuesta nada mantener y que se paga con retención.

JetBrains encuestó a más de 10,000 developers en abril de 2026 y encontró a Claude Code con 91% de satisfacción y un NPS de +54. Números impresionantes que miden costo hundido tanto como calidad. Equipos con cincuenta archivos CLAUDE.md repartidos en sus repos no se cambian. No porque Claude sea irremplazable, sino porque la matemática de migración es lo suficientemente brutal como para matar la conversación antes de que empiece.

Tu .ai/rules.md convierte esa matemática de "dos semanas de reescritura manual" a "ejecutá el script, revisá el diff". No va a portar todo. Ese 20% — la memoria, los comportamientos de runtime, el tuning específico por modelo — sigue costando esfuerzo real. Pero es la diferencia entre estar atrapado por elección y estar atrapado por negligencia.

Las herramientas no quieren que construyas esto. Tampoco te lo impiden. Solo cuentan con que no te vas a molestar.

Molestáte.