2
trsthales
4 min de leitura ·

A IA não tem memória fraca, você que está usando o chat como banco de dados

pactx

Fala pessoal!

Se você usa ChatGPT, Claude, Gemini ou Cursor para tocar projetos que duram mais de uma semana, com certeza já sentiu essa dor: no começo da conversa a IA é impecável, mas conforme a sessão avança ela começa a sugerir refatorações que quebram contratos antigos, esquece regras que vocês já tinham alinhado e passa a propor bibliotecas que você já tinha testado e descartado mensagens atrás.

Durante muito tempo, minha tentativa de contornar isso foi tentar forçar a própria IA a resumir o histórico anterior antes de abrir uma nova sessão, ou ficar copiando e colando arquivos gigantescos de prompt na mão a cada novo chat.

Depois de bater muita cabeça desenvolvendo projetos do zero, percebi que essa abordagem tem um erro conceitual de base: modelos de linguagem sofrem degradação de atenção ao longo de sessões longas (o efeito "Lost in the Middle"). Tentar fazer a própria IA gerenciar a memória do projeto dentro de uma thread volátil é como tentar usar a memória RAM como se fosse um disco rígido.

Isso me fez mergulhar a fundo em engenharia de contexto e me levou a construir o PactX (@trsthales/pactx), uma ferramenta open-source em TypeScript voltada para manter a memória canônica do projeto versionada no Git.

Queria compartilhar aqui as 4 descobertas técnicas mais importantes dessa jornada:

  1. RAG e Bancos Vetoriais puros falham para arquitetura de software:
    Busca por similaridade semântica (embeddings) não entende a passagem do tempo. Se você decidiu usar PostgreSQL na semana passada, mas ontem resolveu mudar para SQLite por tenant, o banco vetorial traz ambas as decisões como "relevantes" porque o texto é parecido. A IA recebe informações contraditórias e alucina tentando misturar as duas. Decisões técnicas precisam de ciclo de vida explícito (ativo vs substituído).

  2. Requisito de Negócio NÃO é Decisão Técnica:
    Misturar o "Espaço do Problema" com o "Espaço da Solução" confunde qualquer modelo. O requisito ("o sistema deve isolar dados por escola para conformidade com a LGPD") é permanente e imutável. A decisão técnica ("usar arquivos SQLite separados") pode mudar no mês que vem. Separar os dois faz com que uma refatoração de código não destrua a regra de negócio original.

  3. Conhecimento Negativo vale mais que o positivo:
    Registrar o que NÃO funcionou é mais valioso para a IA do que listar o que deu certo. Se você gastou 2 horas descobrindo que um erro 403 era causado pelo proxy reverso limpando headers e não por CORS, isso precisa ser persistido formalmente como "Hipótese Descartada". Caso contrário, em qualquer novo chat a IA vai sugerir mexer no CORS de novo.

  4. Persistência em arquivos exige garantias de banco de dados:
    Deixar uma IA alterar arquivos Markdown no seu repositório abre uma caixa de pandora de falhas silenciosas:

  • O que acontece se o processo tomar um SIGKILL ou faltar energia entre a escrita e o commit?
  • E se o modelo tentar sobrescrever um link simbólico ou escapar do diretório?
    Para resolver isso, tive que implementar no PactX um motor de Write-Ahead Logging (WAL) com máquina de estados (PREPARED -> APPLYING -> COMMITTED), escrita atômica com troca de arquivo temporário (renameSync), quarentena de falhas e auto-recovery no boot sob lock exclusivo.

A Tese que resume o projeto:

"Modelos de IA são processadores sem estado (stateless compute). O seu repositório Git é a memória persistente."

Em vez de confiar no histórico volátil de chats na nuvem, o PactX automatiza esse ciclo:

  • Egress (pactx pack): Inspeciona o Git e a pasta .ai-context/ (ADRs, requisitos, invariantes e hipóteses descartadas) e monta um Context Pack compacto em Markdown (~400 tokens) para o clipboard.
  • Ingress (pactx update): Lê o bloco de handoff emitido pela IA, valida com Zero-Trust e aplica as alterações com semântica de Patch (nunca apaga dados não mencionados).
  • Servidor MCP Nativo (pactx serve --mcp): Conexão direta via stdio para Cursor e Claude Desktop consultarem contexto e registrarem micro-âncoras em tempo real sem copiar e colar.
  • Suíte de Governança: Comandos como pactx status (dashboard com telemetria), pactx doctor (10 regras de integridade com --fix) e pactx rollback (reversão transacional determinística).

Para quem quiser testar em 1 minuto:

  1. Inicializa no projeto:
    npx @trsthales/pactx init

  2. Copia o contexto para colar no chat da IA:
    npx @trsthales/pactx

  3. No final da sessão de código, peça /handoff e sincronize:
    npx @trsthales/pactx update

O projeto está 100% aberto (MIT) com mais de 140 testes automatizados:

GitHub: https://github.com/trsthales/pactx
NPM: https://www.npmjs.com/package/@trsthales/pactx

Como vocês têm feito para evitar que IAs como Claude e ChatGPT percam o contexto e esqueçam decisões em projetos mais longos? Alguém mais já enfrentou esses problemas com RAG vetorial ou perda de hipóteses descartadas?

Carregando publicação patrocinada...
2

Será que o problema aí é a IA ou a falta de engenharia básica no dia a dia? 😅

Requisitos, Invariantes e Decisões são documentos canônicos que qualquer projeto sério já deveria manter para humanos, não .ai-context.

Às vezes sinto que estão tentando criar soluções super rebuscadas quando o "feijão com arroz" da engenharia de software já resolveu esse problema a 50 anos!

2

Concordo, um readme no qual a IA atualiza um resumo sequêncial do que foi feito e porque foi realizado dessa forma, já garantiu o andamento confiável de vários projetos meus, alguns nos quais troquei de modelo e de harness ou revisitei depois de meses para lembrar o que foi feito.

1

Pior que vocês tocaram no ponto central: a ideia toda do projeto é justamente resgatar esse feijão com arroz clássico da engenharia de software (ADRs, requisitos claros e invariantes de negócio). Ninguém aqui tá tentando reinventar a roda da computação.

Tanto que a pasta .ai-context não tem nada de formato proprietário ou mirabolante: são literalmente arquivos Markdown normais (decisions/DEC-001.md, requirements.md, glossary.md) que qualquer desenvolvedor humano lê e edita direto no VS Code.

A única razão de ter construído a CLI foi eliminar o trabalho braçal e a fricção no fluxo diário:

  • No início do chat: em vez de ficar copiando e colando regras na mão toda vez (ou jogar a pasta docs/ inteira no prompt e queimar 20k tokens à toa), a CLI empacota só o que está ativo em ~400 tokens em 1 segundo.
  • No final do chat: em vez de você ter que parar no meio do fluxo para criar o arquivo da ADR, numerar e formatar o markdown na mão, a CLI recebe a proposta estruturada da IA e atualiza os arquivos locais de forma atômica no Git.

Essa prática que o @batataQuente comentou de manter um resumo sequencial do que foi feito e os motivos é exatamente o caminho certo. O PactX é só o script/ferramenta que automatiza esse processo repetitivo pra gente focar em programar em vez de ficar organizando markdown manualmente a cada troca de sessão.

Valeu demais pelo contraponto, vocês resumiram a essência da coisa!