La semaine dernière, j'ai posé le diagnostic : six outils de code IA, six formats de config propriétaires, zéro interopérabilité. CLAUDE.md invisible pour Cursor. .cursor/rules sans aucun sens pour Copilot. Des semaines d'intelligence collective enfermées dans le parser du vendeur qui daigne les lire.

Toutes les réactions à ce billet confirmaient que le verrouillage est réel — avant de poser la même question : « Bon, et concrètement, je fais quoi ? » Légitime. Diagnostiquer une prise d'otages sans plan d'extraction, c'est du commentariat. Voici le plan d'extraction.

Pourquoi « choisis bien ton outil » ne suffit plus

Le terrain a bougé trois fois en une seule semaine. GitHub a gelé toutes les souscriptions individuelles à Copilot le 20 avril parce que le compute agentique a explosé ce qu'un abonnement forfaitaire peut couvrir — Joe Binder, VP Produit, a admis que « les workflows agentiques ont fondamentalement changé les besoins en compute de Copilot ». Le 15 avril, Zed a livré les subagents parallèles et une passerelle LLM universelle. Le 14 avril, Anthropic a transformé Claude Code en application desktop avec des Routines déclenchées depuis le cloud. OpenAI a mis à jour son Agents SDK le 15 avril avec l'exécution sandboxée et les intégrations MCP. Les outils mutent chaque semaine. Tes règles ne devraient pas rester prisonnières de celui que tu as choisi il y a six mois.

Tu connais déjà le problème. Ce guide te donne une solution fonctionnelle que tu peux commit aujourd'hui.

Le correctif : un fichier canonique, cinq copies vendeur

Le concept est d'une simplicité insultante. Tu gardes un fichier de règles source-de-vérité dans un répertoire neutre. Tu le synchronises vers chaque format vendeur avec un script shell. Tu ne touches jamais les fichiers vendeur directement.

Étape 1 : Crée .ai/rules.md

Choisis un nom de répertoire qu'aucun vendeur n'a revendiqué. .ai/ fait l'affaire.

.ai/
├── rules.md           # Règles canoniques du projet
├── architecture.md    # Contexte d'architecture
├── patterns.md        # Conventions de code
└── sync.sh            # Le script qui te libère

Ton rules.md est du Markdown pur :

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

# Project Rules

## Code Style
- Strict TypeScript. No `any`. Ever.
- Python: Black formatter, 88-char lines.
- All functions get docstrings. No exceptions.

## Architecture
- Monorepo: apps/ for services, packages/ for shared libs.
- API routes in `src/routes/`, logic in `src/services/`.
- Never import across apps directly. Use packages.

## Testing
- Unit tests co-located: `foo.ts` → `foo.test.ts`.
- Integration tests in `__tests__/integration/`.
- 80% branch coverage minimum on services/.

## Deployment
- Main branch auto-deploys to staging.
- Production: manual approval + passing E2E.
- Env vars in Vault, never in .env files.

## Gotchas
- Payments service uses legacy Stripe v2 client. Don't refactor — vendor contract.
- GraphQL types generate at build time. Run `make codegen` after schema changes.

Source de vérité. N'importe quel outil peut la lire. N'importe quel humain peut la lire. Pas de magie vendeur, juste du Markdown.

Étape 2 : Le script de synchronisation

#!/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."

Vingt lignes. Cinq vendeurs. Une seule source. Tu l'exécutes après chaque modification. C'est tout le secret.

Étape 3 : Automatise, parce que tu ne t'en souviendras pas

Tu te connais. Ajoute un hook pre-commit :

#!/usr/bin/env bash
# .git/hooks/pre-commit (or 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

Tu modifies le fichier canonique, tu commit, les copies vendeur se mettent à jour toutes seules. L'en-tête # Auto-generated dit à tes collègues de ne pas toucher aux fichiers générés.

Étape 4 : Contexte d'architecture

Les règles seules ne suffisent pas. Les outils IA consomment aussi des docs d'architecture et des cartographies de composants. Même principe — tu gardes tout dans .ai/, tu concatènes à la synchro :

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

## Services
- **api-gateway**: Express.js — auth + routing
- **user-service**: Python/FastAPI — owns user data
- **payments**: Node.js — Stripe integration (legacy v2)
- **notifications**: Go — async via SQS

## Data Flow
Requests → api-gateway → service → own DB.
Cross-service: SQS events only. Never direct HTTP.

Étends sync.sh pour concaténer rules.md + architecture.md + patterns.md. Claude Code gère nativement plusieurs fichiers de contexte ; pour les outils qui ne le font pas, un gros fichier unique fait l'affaire.

Ce que tu ne peux pas rendre portable

C'est ici que les vendeurs gagnent leur verrouillage, et que j'arrête de prétendre que ça résout tout.

Les configs de runtime agentique. Les Routines de Claude Code — des agents cloud déclenchés par des planifications ou des événements GitHub — n'ont aucun équivalent chez Cursor. L'orchestration d'agents parallèles de Cursor ne ressemble en rien aux subagents de Zed. Ce sont des comportements d'exécution, pas du contexte statique. Aucun fichier de config ne les capture parce que ce n'est pas de la config. Ce sont des fonctionnalités produit que tu loues.

La mémoire accumulée. Claude Code construit un MEMORY.md au fil du temps — un journal de décisions passées, d'erreurs, de patterns appris. De la connaissance que l'IA génère pendant l'utilisation, pas quelque chose que tu rédiges. Tu ne peux pas la synchroniser parce qu'elle n'existe pas tant que l'IA ne l'a pas créée. Tu changes d'outil, tu perds la mémoire. Comme quand tu changes de psy et que tu repars de la séance un, sauf que le psy a aussi oublié ton prénom.

Le wording calibré pour le modèle. « Toujours utiliser des noms de variables descriptifs » fonctionne partout. Mais si tu as passé des semaines à affiner tes règles pour exploiter la façon dont Claude gère l'ambiguïté ou éviter la tendance de GPT à sur-abstraire, ces nuances ne se portent pas. Modèles différents, bizarreries différentes, modes de défaillance différents.

La couche portable couvre environ 80 % de ce qui rend ton outil IA utile sur ton projet. Les 20 % restants sont véritablement spécifiques au vendeur. Connaître la frontière compte plus que faire semblant qu'elle n'existe pas.

CI : ne fais confiance à personne, surtout pas à toi

Ajoute une détection de dérive à ton 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

Quelqu'un modifie CLAUDE.md à la main ? La CI tue la PR. Dérive éliminée. Une machine qui se fiche de tes sentiments et de ta deadline impose la conformité.

Pourquoi aucun vendeur ne construira ça pour toi

MCP nous a donné un protocole universel pour les connexions d'outils. Personne n'a fait la même chose pour le contexte projet. Pas de standard ai-rules.json, pas de spec d'interopérabilité, pas de groupe de travail. Chaque vendeur profite de l'incompatibilité — un verrouillage accidentel qui ne coûte rien à maintenir et qui rapporte en rétention.

JetBrains a sondé plus de 10 000 développeurs en avril 2026 et a trouvé Claude Code à 91 % de satisfaction avec un NPS de +54. Des chiffres impressionnants qui mesurent autant le coût irrécupérable que la qualité. Des équipes avec cinquante fichiers CLAUDE.md répartis dans leurs repos ne changent pas d'outil. Pas parce que Claude est irremplaçable, mais parce que le calcul de la migration est suffisamment brutal pour tuer la conversation avant même qu'elle commence.

Ton .ai/rules.md transforme ce calcul de « deux semaines de réécriture manuelle » en « lance le script, vérifie le diff ». Ça ne portera pas tout. Ces 20 % — la mémoire, les comportements d'exécution, le tuning spécifique au modèle — coûtent encore un effort réel. Mais c'est la différence entre être verrouillé par choix et verrouillé par négligence.

Les outils ne veulent pas que tu construises ça. Ils ne t'en empêchent pas non plus. Ils comptent juste sur le fait que tu ne te donneras pas la peine.

Donne-toi la peine.