Suas regras de IA para codigo estao presas em vendor lock-in. Aqui vai um jailbreak de 20 linhas

Na semana passada eu diagnostiquei a doença: seis ferramentas de IA para código, seis formatos proprietários de configuração, zero interoperabilidade. CLAUDE.md invisível pro Cursor. .cursor/rules sem sentido pro Copilot. Semanas de inteligência acumulada pelo time trancadas dentro de qualquer parser de vendor que por acaso consiga ler aquilo.

Todo mundo que respondeu àquele post concordou que o lock-in é real — e depois fez a mesma pergunta: "Tá, mas o que eu faço com isso?" Justo. Diagnosticar um sequestro sem plano de resgate é só comentário. Aqui está o plano de resgate.

Por que "escolha com sabedoria" parou de funcionar

O chão mudou três vezes só na última semana. O GitHub congelou todas as assinaturas individuais do Copilot em 20 de abril porque o consumo de computação dos agentes explodiu além do que uma assinatura fixa consegue bancar — o VP de Produto Joe Binder admitiu que "workflows agênticos mudaram fundamentalmente as demandas de computação do Copilot". Em 15 de abril, o Zed lançou subagentes paralelos e um gateway universal de LLM. Em 14 de abril, a Anthropic reconstruiu o Claude Code como app desktop com Routines disparadas na nuvem. A OpenAI atualizou seu Agents SDK em 15 de abril com execução sandboxed e integrações MCP. Ferramentas mutam semanalmente. Suas regras não deveriam estar presas dentro daquela que você escolheu seis meses atrás.

Você já conhece o problema. Este guia te dá uma solução funcional que você pode commitar hoje.

A correção: um arquivo canônico, cinco cópias de vendor

O conceito é ofensivamente simples. Mantenha um único arquivo de regras como fonte da verdade em um diretório vendor-neutral. Sincronize para cada formato de vendor com um script shell. Nunca edite os arquivos de vendor diretamente.

Passo 1: Crie .ai/rules.md

Escolha um nome de diretório que nenhum vendor reclamou. .ai/ serve.

.ai/
├── rules.md           # Regras canônicas do projeto
├── architecture.md    # Contexto de design do sistema
├── patterns.md        # Convenções de código
└── sync.sh            # O script que te liberta

Seu rules.md é Markdown puro:

---
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.

Fonte da verdade. Qualquer ferramenta lê. Qualquer humano lê. Sem mágica de vendor, só Markdown.

Passo 2: O script de sincronização

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

Vinte linhas. Cinco vendors. Uma fonte. Rode depois de cada edição. É o truque inteiro.

Passo 3: Automatize porque você não vai lembrar

Você se conhece. Adicione um pre-commit hook:

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

Edita o arquivo canônico, commita, as cópias de vendor se atualizam sozinhas. O header # Auto-generated avisa os colegas para não meterem a mão nos arquivos gerados.

Passo 4: Contexto de arquitetura

Regras sozinhas não bastam. Ferramentas de IA também consomem docs de arquitetura e mapas de componentes. Mesmo padrão — mantenha em .ai/, concatene durante o sync:

<!-- .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.

Estenda o sync.sh para concatenar rules.md + architecture.md + patterns.md. O Claude Code lida com múltiplos arquivos de contexto nativamente; para ferramentas que não lidam, um arquivo grandão resolve.

O que você não consegue tornar portável

Aqui é onde os vendors ganham o lock-in deles, e onde eu paro de fingir que isso resolve tudo.

Configs de runtime de agentes. As Routines do Claude Code — agentes na nuvem disparados por schedules ou eventos do GitHub — não têm equivalente no Cursor. A orquestração de agentes paralelos do Cursor funciona de forma completamente diferente dos subagentes do Zed. São comportamentos de runtime, não contexto estático. Nenhum arquivo de configuração captura isso porque não é configuração. São funcionalidades de produto que você está alugando.

Memória acumulada. O Claude Code constrói o MEMORY.md ao longo do tempo — um registro de decisões passadas, erros, padrões aprendidos. Conhecimento que a IA gera durante o uso, não algo que você escreve. Você não consegue sincronizar porque não existe até a IA criar. Troca de ferramenta, perde a memória. Como trocar de terapeuta e começar da sessão um, só que o terapeuta também esqueceu o seu nome.

Redação ajustada ao modelo. "Sempre use nomes descritivos para variáveis" funciona em qualquer lugar. Mas se você passou semanas calibrando regras para explorar como o Claude lida com ambiguidade ou desviar da tendência do GPT de abstrair demais, essas nuances não portam. Modelos diferentes, quirks diferentes, modos de falha diferentes.

A camada portável cobre aproximadamente 80% do que torna sua ferramenta de IA útil no seu projeto. Os 20% restantes são genuinamente vendor-specific. Saber onde está a fronteira importa mais do que fingir que ela não existe.

CI: não confie em ninguém, especialmente em você mesmo

Adicione detecção de drift no seu 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

Alguém editou CLAUDE.md na mão? CI mata o PR. Drift eliminado. Uma máquina que não liga pros seus sentimentos nem pro seu deadline garante conformidade.

Por que nenhum vendor vai construir isso pra você

O MCP nos deu um protocolo universal para conexões de ferramentas. Ninguém fez o mesmo para contexto de projeto. Nenhum padrão ai-rules.json, nenhuma spec de interoperabilidade, nenhum grupo de trabalho. Todo vendor se beneficia da incompatibilidade — lock-in acidental que custa zero pra manter e paga em retenção.

A JetBrains pesquisou mais de 10.000 desenvolvedores em abril de 2026 e encontrou o Claude Code com 91% de satisfação e NPS de +54. Números impressionantes que medem custo irrecuperável tanto quanto qualidade. Times com cinquenta arquivos CLAUDE.md espalhados pelos repos não trocam. Não porque o Claude é insubstituível, mas porque a matemática da migração é brutal o suficiente pra matar a conversa antes dela começar.

Seu .ai/rules.md transforma essa matemática de "duas semanas de reescrita manual" em "rode o script, confira o diff". Não vai portar tudo. Aqueles 20% — a memória, os comportamentos de runtime, o tuning específico do modelo — ainda custam esforço real. Mas é a diferença entre estar preso por escolha e estar preso por negligência.

As ferramentas não querem que você construa isso. Também não impedem. Só contam com você não se dando ao trabalho.

Dê-se ao trabalho.