Como usar o GPT-6 Astra para entender um repositório legado que ninguém documentou

Fala aí, beleza? Existe um tipo de repositório que todo dev encontra pelo menos uma vez: sem README, sem o autor original na empresa, com o último commit assinado por alguém que ninguém sabe quem é… e rodando em produção agora, servindo cliente de verdade

A OpenAI anunciou o GPT-6 Astra em 3 de setembro de 2026, apresentando o modelo como estado da arte em uso de computador, navegação, engenharia de software, cibersegurança, ciência e trabalho profissional

Esse post não é review

É um fluxo prático: como usar o modelo pra mapear um projeto herdado passo a passo, do inventário de pastas até a documentação inicial, e principalmente COMO conferir o que ele afirmou antes de você transformar aquilo em documento oficial do time

O que você precisa antes de começar

Primeiro a parte chata, que é justamente a que evita frustração 🙂

Acesso ao modelo:

O GPT-6 Astra foi liberado hoje para um conjunto limitado de organizações, as empresas do Trusted Access Program

O acesso via API e pelos planos ChatGPT Plus, Pro, Business e Enterprise chega nos próximos dias, segundo a própria OpenAI

Ele também é oferecido fora da API da OpenAI, no Amazon Bedrock da AWS

Ou seja: se ainda não apareceu pra sua conta, não é bug, é rollout

Onde selecionar o Astra:

O GPT-6 Astra é posicionado para trabalho complexo em código, apps e pesquisa no Codex e no ChatGPT Work, combinando raciocínio avançado, uso de computador e julgamento mais forte

Formação Recomendada

Formação Claude Code

Domine Claude Code do absoluto zero até o avançado

• 114 aulas
• 4 projetos
• 9h 18min

Conhecer formação

Quando ele estiver disponível pra sua conta, você escolhe no seletor de modelos do Codex

No Codex CLI dá pra definir o modelo já na inicialização, pela flag --model (ou o alias -m):

# escolhendo o modelo na inicialização do Codex CLI
codex --model <identificador-do-modelo>

# mesma coisa, versão curta
codex -m <identificador-do-modelo>

Já com a sessão interativa aberta, o comando /model troca o modelo ou ajusta o esforço de raciocínio sem você sair de onde está

O identificador do modelo na API da OpenAI é gpt-6-astra

Qual string exatamente aparece no seletor do Codex, confere no próprio seletor: melhor olhar do que chutar

Esforço de raciocínio:

O parâmetro reasoning.effort aceita low, medium, high, xhigh e max

Detalhe importante: o GPT-6 Astra NÃO suporta o nível none

Pra leitura de código legado, esforço baixo tende a te dar resposta bonita e rasa

Esforço alto custa mais tokens de saída, e token de saída é o caro da conta

Aviso de custo (leia antes de jogar o repo inteiro lá dentro):

O preço padrão na API é US$ 10 por milhão de tokens de entrada e US$ 50 por milhão de tokens de saída, com a entrada em cache saindo por US$ 1 por milhão

Pra fazer a conta em real, o câmbio de 3 de setembro de 2026 é US$ 1 = R$ 5,0933

E tem a pegadinha dos prompts gigantes: acima de 272 mil tokens de entrada, o multiplicador vale para a REQUISIÇÃO INTEIRA, com 2x nas taxas de entrada e de cache e 1,5x na saída

Repara que não é só o excedente que fica mais caro, é tudo aquilo

A janela é de 1.050.000 tokens de contexto, então dá pra enfiar coisa demais ali sem perceber que você cruzou a linha 😀

Corte de conhecimento:

A data de corte de conhecimento do GPT-6 Astra é 30 de abril de 2026

Tradução prática: dependência mais nova que isso, ou versão de framework lançada depois, o modelo só conhece pelo que estiver dentro do seu repositório

Se ele falar com segurança sobre uma lib recente sem citar arquivo do projeto, acende a luz amarela

Passo a passo para mapear um repositório legado com o GPT-6 Astra

A lógica do fluxo é uma só: ir do mais barato e mais verificável para o mais caro e mais interpretativo

Inventário primeiro, opinião por último

1. Inventário do repositório:

Começa pelo mapa físico do projeto: estrutura de pastas, linguagens presentes, arquivos de build e de configuração

Nada de análise profunda aqui, só o esqueleto

Você vai analisar um repositório legado sem documentação.
Nesta primeira etapa, NÃO explique lógica de negócio.

Me devolva apenas:
1. árvore de diretórios até 2 níveis, com uma linha por pasta dizendo o que ela parece conter
2. linguagens e versões que aparecem nos arquivos de configuração
3. arquivos de build, empacotamento e CI encontrados (caminho exato)
4. arquivos que você NÃO conseguiu classificar

Para cada item, cite o caminho do arquivo que sustenta a afirmação.
Se não houver arquivo que sustente, escreva "não encontrado no repositório".

O item 4 é o mais valioso da lista, porque é onde mora o que você ainda não entendeu

O erro comum deste passo: despejar o repositório inteiro de uma vez

Além de você estourar os 272 mil tokens de entrada e pagar o multiplicador sem perceber, a resposta vira genérica

Começa por um módulo ou por uma pasta de cada vez

2. Identificar os pontos de entrada:

Ponto de entrada é por onde o mundo externo toca no sistema: main, rotas HTTP, handlers de fila, jobs agendados, comandos de CLI

Enquanto você não tem essa lista, qualquer explicação sobre o sistema é chute educado

Liste TODOS os pontos de entrada deste código, agrupados por tipo:
- processo principal (main, bootstrap, servidor)
- rotas HTTP
- consumidores de fila ou eventos
- jobs agendados (cron, scheduler)
- comandos de CLI

Formato: tipo | nome | arquivo:linha | primeira função chamada
Se você não tiver certeza de que algo é ponto de entrada, coloque em uma
seção separada chamada "candidatos a verificar".

Esse formato com arquivo:linha não é firula: é o que te deixa conferir em 10 segundos

O erro comum deste passo: aceitar nome de arquivo inventado

O modelo escreve src/routes/admin.py com toda a confiança do mundo e o arquivo simplesmente não existe

Abre a lista, confere cada caminho, corta o que não bate

3. Reconstruir o caminho de uma requisição:

Agora escolhe UM ponto de entrada, de preferência o mais usado, e pede o trajeto completo até o banco de dados

Um por vez, sempre

Rastreie o caminho completo desta requisição: <método e rota>

Para cada salto, me dê:
arquivo:linha -> função -> o que ela faz em uma frase -> próximo salto

Inclua middlewares, validações, camada de serviço, acesso a banco
(query ou ORM) e a resposta devolvida.
Se a cadeia quebrar em algum ponto porque você não achou o destino,
pare e escreva onde quebrou. Não preencha a lacuna por dedução.

Aquele "não preencha a lacuna por dedução" é a linha mais importante do prompt inteiro

É nela que você troca uma história redondinha por uma verdade incompleta, que é o que você quer aqui

Esse tipo de rastreio guiado é o mesmo raciocínio que já usamos por aqui pra entender um projeto legado com o Claude Code, então se você já rodou aquele fluxo, o terreno é familiar

O erro comum deste passo: aceitar um fluxo plausível mas invertido

Validação depois da escrita no banco, cache consultado no lugar errado, esse tipo de coisa

É plausível, lê bem, e está errado

4. Listar as dependências e onde elas são realmente usadas:

Dependência declarada não é dependência usada

O que interessa é o cruzamento: o que está no manifesto e onde aquilo aparece no código

A partir dos arquivos de manifesto do projeto (cite quais você usou),
monte uma tabela:

pacote | versão declarada | arquivos que importam | direta ou transitiva

Regras:
- só liste pacote que aparece no manifesto, copiando o nome exato
- se um pacote está declarado e você não achou nenhum import, marque
  como "declarada, sem uso encontrado"
- se um import aparece no código e não está no manifesto, marque como
  "usada, não declarada" (isso é achado, não erro seu)

Essa última categoria costuma render descoberta boa em projeto antigo

Se o seu objetivo é enxergar as relações entre módulos de forma mais estrutural, existe também a abordagem de montar um grafo de dependências do projeto, que resolve outra parte do mesmo problema

O erro comum deste passo: deixar entrar dependência que não está no manifesto real

O modelo conhece o ecossistema e completa a lista com o que "normalmente" tem em projeto assim

Compara linha a linha com o arquivo de manifesto, sempre

5. Mapear efeitos colaterais e integrações externas:

Aqui é onde o legado morde: escrita em disco, envio de e-mail, chamada pra API de terceiro, fila, webhook, variável de ambiente que muda comportamento

Liste tudo que este código faz para FORA dele mesmo:
- chamadas HTTP para serviços externos (URL ou variável de ambiente usada)
- escrita em disco, fila, cache ou storage
- envio de e-mail, SMS ou notificação
- variáveis de ambiente lidas e o que muda quando cada uma está ausente

Formato: efeito | arquivo:linha | disparado a partir de qual ponto de entrada

É essa lista que responde a pergunta que todo mundo faz antes de mexer: "se eu alterar isso aqui, o que vai acontecer no mundo real?"

O erro comum deste passo: confundir código morto com integração ativa

Tem chamada de API que está lá desde 2019 e nunca mais é atingida por nenhuma rota

Cruza com a lista do passo 2 e marca o que não tem caminho de entrada

6. Gerar a documentação inicial, em blocos:

Só agora, com o mapa conferido na mão, faz sentido pedir texto

O limite máximo de saída é de 128.000 tokens, então documentação de projeto grande sai em partes de qualquer jeito

Pede por módulo, não por repositório

Com base APENAS no que foi confirmado nas etapas anteriores, escreva a
documentação do módulo <nome do módulo>.

Seções: propósito, pontos de entrada, fluxo principal, dependências,
efeitos colaterais, pontos de atenção.

Regras:
- toda afirmação técnica precisa citar arquivo:linha
- o que não foi confirmado vai em uma seção final chamada
  "a verificar", em vez de virar afirmação
- não escreva instruções de instalação ou deploy que você não
  conseguiu extrair de um arquivo do repositório

O erro comum deste passo: pedir documentação antes de ter o mapa

O texto sai lindo, com títulos, tom profissional e tudo

E aí ele entra no repositório como verdade oficial, alguém confia dali a três meses e o estrago já tem carimbo do time 😛

Quando esse fluxo compensa (e quando não)

Não é todo projeto que pede essa artilharia toda, então vale separar

Compensa em:

• onboarding em projeto herdado, quando você tem uma semana pra virar responsável por algo que ninguém explica direito
• auditoria antes de refatorar, porque o mapa de efeitos colaterais é exatamente a lista do que pode quebrar
• preparação pra migração, onde a lista de dependências e integrações externas define o tamanho real do trabalho
• entender um serviço antes de entrar de plantão, pra não descobrir a arquitetura às 3 da manhã com o alerta tocando

Não compensa em:

• repositório pequeno, que você lê numa tarde com café e paciência
• código que já tem documentação atualizada, onde o custo vira só uma segunda opinião cara

E tem o caso do prazo apertado: existe um modo Fast para o GPT-6 Astra na API, que entrega até 2x a velocidade do processamento Standard por 2x o preço Standard

Ou seja, é uma troca direta de dinheiro por tempo

Só liga isso quando a latência realmente pesar mais que a fatura, tipo incidente em andamento

Pra mapeamento tranquilo de repositório, Standard resolve

Como conferir o que o modelo afirmou antes de virar documentação oficial

Essa é a seção que separa documentação útil de ficção bem formatada

A lógica é simples: o modelo GERA, você VERIFICA

E tem número pra justificar essa desconfiança saudável

A Artificial Analysis mediu, no AA-Omniscience, a taxa de alucinação caindo de 92% para 51% no esforço max, com aumento de 4 pontos na acurácia

Melhora enorme, sem discussão

Mas repara no que 51% significa na prática: cerca de metade das respostas ainda erra em conhecimento factual

Na mesma casa, a pontuação no Artificial Analysis Intelligence Index é de 61 pontos na variante max e 60 pontos na variante high

Modelo forte não é modelo dispensado de conferência

Sintoma: arquivo ou função que não existe

Causa: o modelo completou o padrão do ecossistema em vez de ler o seu repositório

Solução: exigir arquivo:linha em toda afirmação e abrir cada caminho citado

É verificação mecânica, roda rápido, e derruba a maioria dos casos

Sintoma: fluxo plausível, porém invertido

Causa: a ordem das camadas foi deduzida pela convenção do framework, não pela leitura da chamada real

Solução: rodar o código

Coloca um log em cada salto do caminho que o modelo descreveu, dispara a requisição e compara a ordem real com a ordem descrita

Cinco minutos de log valem mais que meia hora de leitura de texto bonito

Sintoma: dependência listada que não está no manifesto

Causa: conhecimento geral do ecossistema vazando pra dentro da análise do seu projeto

Solução: abrir o arquivo de manifesto e comparar nome por nome, versão por versão

Nada de diff mental: o manifesto é a fonte da verdade

Sintoma: comportamento descrito de forma genérica demais

Causa: a descrição veio do que aquela biblioteca costuma fazer, não do que o SEU código faz com ela

Solução: pedir o trecho literal do arquivo que sustenta a frase

Se o modelo não conseguir colar o trecho, a frase não entra na documentação

Como prevenir: a rotina antes de commitar

Uma checklist curta, que dá pra rodar em qualquer módulo:

1. todo caminho de arquivo citado foi aberto e existe
2. toda função citada foi encontrada no arquivo e na linha indicada
3. o fluxo principal foi executado pelo menos uma vez com log ou debugger
4. a lista de dependências bate com o manifesto, item a item
5. o que sobrou sem confirmação está numa seção "a verificar", e não escondido no meio do texto
6. a documentação diz em que data ela foi gerada e contra qual commit

O item 6 é barato e salva o time depois

Documentação sem commit de referência envelhece em silêncio

O que os números do GPT-6 Astra dizem sobre trabalho em código legado

Não é review, é justificativa de escolha: por que usar esse modelo pra esse tipo de tarefa

O Terminal-Bench 4.0 é um benchmark de tarefas de terminal que inclui engenharia de software, configuração de sistema e análise de dados

Ou seja, é o tipo de coisa que se parece com o trabalho de quem está fuçando um repositório: rodar comando, ler saída, decidir o próximo passo

E o posicionamento oficial vai na mesma direção: o modelo é apresentado para trabalho complexo em código, apps e pesquisa no Codex e no ChatGPT Work

Uma nota que pesa antes de subir código proprietário:

O GPT-6 Astra é o primeiro modelo designado pela OpenAI como tendo atingido o limiar critical em capacidade cibernética, dentro do Preparedness Framework da própria empresa

Isso não é detalhe de rodapé quando o repositório que você quer mapear é o código proprietário da sua empresa

Vale passar pela política interna antes, não depois

Sobre reprodutibilidade:

O modelo não aceita valores customizados de temperature ou top_p, nem logprobs

Então aquele truque de baixar a temperatura pra ter resposta mais estável não existe aqui

A consistência vem do prompt: formato de saída fixo, exigência de citação de arquivo e linha, escopo pequeno por requisição

É menos botão pra girar e mais texto pra escrever direito

Vídeo: recursos de assistente de código que ajudam nesse fluxo

Boa parte desse trabalho acontece no terminal, com um assistente de código do lado

Pra começar do zero nesse ambiente, este vídeo do canal mostra 20 recursos do Claude Code, do básico ao avançado:

Próximo passo: escolha um repositório e comece pelo ponto de entrada

Se tem uma ideia pra levar desse post, é essa: o valor do fluxo está na verificação, não na geração

Gerar texto sobre código é a parte fácil e barata

Conferir arquivo, linha, ordem de chamada e manifesto é o que transforma aquilo em documentação que o time pode confiar daqui a seis meses

O próximo passo concreto é bem pequeno: escolhe UM módulo do seu projeto herdado, roda os passos 1 a 3, confere tudo contra o código e só então expande pro resto

Se o mapa do primeiro módulo sobreviver à conferência, você já sabe que o fluxo funciona no seu contexto

E dois lembretes pra fechar: a conta é de US$ 10 por milhão de tokens de entrada e US$ 50 por milhão de saída, com multiplicador acima de 272 mil tokens de entrada, então fatiar não é só boa prática, é economia

E o acesso hoje ainda é limitado às organizações do Trusted Access Program, com API e planos do ChatGPT chegando nos próximos dias

Dá tempo de preparar os prompts enquanto o botão não aparece pra você 😀

até o próximo post!