No primeiro artigo desta série, explicámos como preparar um computador para fazer vibe coding. Instalámos Linux, configurámos Codex e Antigravity, ligámos o GitHub e publicámos a nossa primeira aplicação através do Railway.
Conseguimos desenvolver uma pequena aplicação com inteligência artificial sem escrevermos nós próprios o código.
Mas aquilo foi um teste. Pedimos ao Codex para programar, verificámos que funcionava e depois utilizámos o Antigravity para rever o resultado. Para começar, está bem, mas, se queremos trabalhar em projetos reais, precisamos de algo mais organizado.
O que acontece quando temos várias funcionalidades pendentes? Como evitamos que a IA modifique ficheiros em que não devia mexer? Quem verifica se uma solução está bem pensada antes de a programar? E como sabemos se aquilo que publicámos é exatamente o que revimos?
Para responder a estas perguntas, fui construindo o meu próprio método de trabalho. Não inventei nada de revolucionário: adaptei práticas habituais do desenvolvimento profissional a um ambiente em que grande parte do trabalho é realizada por agentes de inteligência artificial.
Vou explicar como o organizar e utilizar, passo a passo. Talvez te ajude a reproduzi-lo.
Como organizo o trabalho com agentes de IA
A ideia é simples: uma IA desenvolve e outra audita o seu trabalho, enquanto nós mantemos o controlo das decisões importantes.
No meu caso, utilizo cinco ferramentas de base:
| Ferramenta | Função |
| Codex | Analisa, planeia, programa, testa e documenta. |
| Antigravity | Audita de forma independente o plano e o código. |
| GitHub | Guarda o código, as versões e os pull requests. |
| Linear | Organiza tarefas, testes, auditorias e estados. |
| Notion | Guarda requisitos, decisões e o histórico do projeto. |
A estas acrescento mais duas: Local WP quando são desenvolvimentos em WordPress e Convex ou Supabase se for uma aplicação web que precisa de uma base de dados.
O Notion é opcional, embora o recomende para projetos de média dimensão. Mais adiante veremos porquê.
Também não somos obrigados a utilizar exatamente estas aplicações. Podemos substituir o Codex pelo Claude Code, por exemplo, ou escolher outro agente como auditor. O essencial é manter as responsabilidades separadas.
O procedimento completo é:
- Requisitos.
- Plano técnico.
- Primeira auditoria.
- Desenvolvimento e testes.
- Segunda auditoria.
- GitHub.
- Implementação em produção.
- Verificação.
Os passos 2 (Codex) e 3 (Antigravity) podem repetir-se várias vezes: se o Antigravity encontrar um problema, o Codex corrige-o e repetimos a revisão. A ideia é avançar através de ciclos de trabalho e verificação, sem passar à fase seguinte enquanto houver problemas relevantes por resolver.
Na minha forma de trabalhar há duas auditorias obrigatórias, embora a sua profundidade dependa da complexidade do desenvolvimento. A primeira revê o que vamos fazer; a segunda verifica o que realmente fizemos.
E um aspeto importante: um GO do auditor não equivale a autorização para publicar. Essa decisão continua a ser nossa.
Passo 1. Preparar o nosso ambiente de trabalho com o Codex
Partimos do computador configurado no primeiro tutorial. Já temos Codex, Antigravity e GitHub a funcionar, por isso não vamos repetir as instalações.
Abrimos um terminal na pasta do projeto e iniciamos o Codex:
cd ~/Proyectos/mi-proyecto
codex
Agora vem uma das partes de que mais gosto ao trabalhar com agentes: não precisamos de configurar manualmente toda a estrutura do projeto. Podemos pedir ao Codex que a prepare.
Prompt 1. Configurar o ambiente de trabalho
Quero preparar este projeto para trabalhar através de um procedimento de desenvolvimento supervisionado por IA.
Tu atuarás como analista e programador. O Antigravity será o auditor independente. Utilizaremos o GitHub para o código, o Linear para as tarefas e, opcionalmente, o Notion para a documentação.
Inspeciona o projeto e verifica as ligações disponíveis. Propõe as instruções permanentes, a documentação mínima, as regras de permissões e um procedimento com duas auditorias obrigatórias: ao plano técnico e ao código.
As implementações, as operações Git importantes e as publicações exigem autorização humana. As tarefas só são encerradas depois de verificar o funcionamento em produção.
Apresenta primeiro um plano de configuração. Não cries ficheiros nem modifiques serviços antes de receber autorização.
O Codex deverá analisar o que temos disponível e dizer-nos o que falta.
Normalmente haverá algumas operações que teremos de realizar pessoalmente:
- Iniciar sessão no Linear ou no Notion.
- Autorizar uma integração.
- Aceitar permissões ou criar uma ligação que exija autenticação através do navegador.
MUITO IMPORTANTE: não devemos dar-lhe palavras-passe nem tokens, colando-os diretamente no chat.
Utilizaremos os mecanismos de autenticação de cada serviço (o GitHub e o Cloudflare têm-nos) e concederemos apenas as permissões necessárias.
Depois de aprovarmos a configuração, o Codex poderá preparar os ficheiros e organizar as ferramentas.
Mas vamos verificar se realmente o fez, por isso pedir-lhe-emos que o confirme. Um agente não pode criar uma ligação ao Linear se o seu ambiente não tiver uma integração compatível.
Passo 2. Organizar a documentação sem encher o repositório de ficheiros
Para trabalhar com agentes precisamos de algo que as conversas, por si só, não oferecem: memória operacional do projeto.
Imagina que já desenvolvemos durante várias semanas e iniciamos uma nova sessão do Codex. Não queremos voltar a explicar-lhe toda a arquitetura, as ferramentas que utilizamos, os ficheiros em que pode mexer e como funciona a publicação.
Para evitar isso, utilizaremos dois documentos básicos dentro do repositório:
- AGENTS.md: instruções permanentes para o Codex, limites de atuação e regras de desenvolvimento.
- PROJECT.md: descrição do projeto, arquitetura básica, ambientes e ligações à documentação.
O Codex pode criá-los a partir dos nossos requisitos.
E para que precisamos do Notion?
Em projetos pequenos, os ficheiros Markdown podem ser suficientes para documentar alterações e decisões. Mas, quando começamos a acumular funcionalidades, decisões, requisitos e mudanças de arquitetura, acabamos com demasiados documentos dentro do repositório.
Por isso, recomendo o Notion para projetos de média dimensão.
É aí que guardaremos principalmente os PRD (Product Requirements Document), as decisões técnicas e o histórico do projeto. O Linear reunirá as tarefas, os seus estados, as auditorias e os testes. O GitHub guardará o código.
O interessante é que o Notion e o Linear serão utilizados sobretudo pelos próprios agentes. O Codex redigirá e atualizará a documentação, consultará os requisitos antes de programar e registará os resultados. O Antigravity precisará de ler essa informação para auditar.
Não teremos de escrever manualmente páginas e páginas de documentação. A nossa responsabilidade será verificar se os requisitos e as decisões importantes refletem o que queremos.
Passo 3. Definir o que queremos desenvolver
Vamos usar como exemplo um desenvolvimento real que fiz para este site.
Na minha revista, as páginas de etiquetas mostravam as publicações por ordem cronológica. Queria melhorá-las para que destacassem os conteúdos mais interessantes sem perder a listagem habitual.
Este é o tipo de necessidade que podemos explicar ao Codex em linguagem natural, sabendo que um pedido assim deixa muitas perguntas em aberto.
- Quantos artigos devemos destacar?
- Como decidimos quais são relevantes?
- O que acontece aos restantes?
- Deve funcionar em todas as páginas?
- Que elementos não queremos modificar?
Antes de analisar seja o que for, convém esclarecer estas questões.
Prompt 2. Preparar requisitos e plano técnico
Quero desenvolver esta funcionalidade: [DESCRIÇÃO].
Lê as instruções e a documentação do projeto. Transforma a necessidade em requisitos verificáveis e critérios de aceitação. Prepara ou atualiza o PRD e organiza as tarefas necessárias no Linear.
Examina o código existente e propõe a solução mais simples que cumpra os requisitos, identificando os ficheiros afetados, os riscos, as alternativas e os testes.
Não programes ainda. Pergunta-me quais são as decisões funcionais que não consegues resolver com a informação disponível e prepara o plano para uma auditoria independente.
Esta é uma das mudanças mais importantes em relação a simplesmente pedir a uma IA para programar alguma coisa.
O Codex pode ajudar-nos a transformar uma ideia numa especificação. Nós decidimos se essa especificação corresponde à nossa necessidade.
No caso das etiquetas, por exemplo, o critério de aceitação não podia limitar-se ao aparecimento de artigos destacados. Também precisávamos de preservar a navegação, evitar duplicações indesejadas e manter o funcionamento correto nas diferentes páginas.
Uma vez aprovada a abordagem, o Codex regista-a e prepara o plano técnico.
Ainda não escrevemos uma única linha de código.
Design do front-end
Neste caso, eu tinha muito claro o design que queria, por isso não pedi propostas visuais. No entanto, noutras ocasiões pediria essas propostas nesta fase, para que fossem consideradas antes de me apresentarem a solução técnica.
Obviamente, se sabes o que queres, explicas e pronto. Ou, se precisas de uma funcionalidade que afeta o back-end e não o front-end, também não vais precisar de mockups.
Passo 4. Primeira auditoria: verificar o plano com o Antigravity
Agora entra em ação o nosso segundo agente.
Abrimos outro terminal na mesma pasta do projeto e executamos:
agy
No meu procedimento atual, o Antigravity funciona manualmente. Não deixamos que o Codex o invoque automaticamente e continue sem termos revisto o resultado.
Queremos que atue como auditor independente, não como outro programador que começa a modificar ficheiros.
Prompt 3. Auditar o plano técnico
Atua exclusivamente como auditor técnico independente.
Revê as instruções do projeto, os requisitos e o plano proposto pelo Codex. Avalia se a solução é viável, suficientemente simples, segura e compatível com o funcionamento existente.
Verifica os riscos, as possíveis regressões e se os testes previstos são adequados.
Emite um parecer fundamentado: GO, GO condicionado ou NO-GO. Se não tiveres provas suficientes, indica-o expressamente.
Identifica os problemas concretos e as correções necessárias. Não modifiques nenhum ficheiro.
Porquê auditar antes de desenvolver?
Porque uma solução pode estar perfeitamente programada e, mesmo assim, ser uma má solução.
Talvez introduza uma dependência desnecessária, duplique informações existentes, faça demasiadas consultas ou complique a manutenção futura.
Com as etiquetas, por exemplo, não bastava criar um sistema de destaques. Era também necessário avaliar como calcular a sua ordem sem executar operações lentas de cada vez que alguém visitasse uma página.
Se o auditor identificar problemas, transmitimos o relatório ao Codex. Este revê o plano e voltamos a auditá-lo sempre que necessário.
Não começamos a programar antes de termos um plano aceite e autorização humana para o implementar.
Passo 5. O Codex desenvolve e realiza os testes
Com o plano aprovado, começa a implementação.
O Codex trabalhará num ramo do repositório. Se já leste o primeiro artigo, conheces o Git e o GitHub, por isso não precisamos de repetir como os utilizar.
A novidade é que não programamos diretamente sobre a versão estável do projeto. Preparamos as alterações em separado para as podermos rever antes de as integrar.
Prompt 4. Implementar a funcionalidade
Autorizo o desenvolvimento do plano aprovado e auditado correspondente a [TAREFA DO LINEAR].
Trabalha num ramo específico e limita as alterações ao âmbito autorizado.
Implementa a solução, executa os testes adequados e verifica possíveis regressões. Documenta os resultados no Linear.
Prepara o diff completo, identifica os ficheiros modificados e apresenta as provas necessárias para a segunda auditoria.
Não faças merge nem publiques. Para quando o desenvolvimento estiver pronto para revisão.
O Codex pode modificar ficheiros, executar testes e corrigir erros dentro do âmbito que aprovámos.
Mas há algo a que devemos estar atentos: o facto de a IA afirmar que uma funcionalidade funciona não significa que isso tenha sido comprovado.
Precisamos de provas. Consoante o projeto, podem ser testes automatizados, resultados de execução, verificações funcionais ou uma combinação destes elementos.
Também temos de distinguir aquilo que o Codex testou daquilo que ainda não consegue verificar.
Voltando ao nosso exemplo: não basta verificar se aparecem três artigos destacados. Devemos rever o que acontece quando há menos artigos disponíveis, quando mudamos de página ou quando algum conteúdo não tem os dados esperados, como um artigo não traduzido para alguma língua.
O agente deve deixar registo dessas verificações e de quaisquer limitações.
Passo 6. Segunda auditoria: rever o código real
Já temos a funcionalidade desenvolvida, mas ainda não vamos publicá-la.
Voltamos ao Antigravity e pedimos-lhe que reveja o código modificado, não apenas o relatório que o Codex preparou.
Prompt 5. Auditar a implementação
Atua como auditor técnico independente de [TAREFA DO LINEAR].
Revê o diff completo, o plano aprovado, os requisitos e as provas dos testes.
Procura defeitos funcionais, problemas de segurança, regressões, complexidade desnecessária e alterações fora do âmbito autorizado.
Emite um parecer fundamentado e identifica os problemas por ficheiro e localização sempre que possível.
Regista a impressão digital SHA-256 do diff auditado para identificar exatamente a versão revista.
Não modifiques ficheiros nem autorizes commits, merges ou publicações.
Há dois pormenores importantes.
O primeiro é que o Antigravity tem de conseguir consultar as mesmas regras e requisitos utilizados pelo Codex. Caso contrário, corre o risco de aprovar uma solução tecnicamente correta, mas que não cumpre aquilo que pedimos.
O segundo é conservar a documentação do conjunto de alterações auditado. Assim, podemos identificar a versão exata que recebeu o GO e detetar se o código foi modificado depois. Essa impressão digital tem de ser calculada de forma reproduzível sobre o mesmo conteúdo.
No meu caso, guardamos todo o registo no Linear, associado à tarefa correspondente.
Se o Antigravity encontrar erros, voltamos ao Codex, pedimos as correções e repetimos a auditoria.
Dois agentes podem enganar-se, mesmo quando concordam na avaliação. Por isso, as auditorias são controlos adicionais, não garantias absolutas. E, opcionalmente, podemos acrescentar uma terceira.
Passo 7. Integrar as alterações no GitHub
Quando obtemos um GO da auditoria, podemos preparar a integração. O procedimento habitual é:
Branch > Commit > Push > Pull Request > Merge.
Não precisamos de executar manualmente esses comandos. O Codex pode tratar disso, mas temos de compreender o que estamos a autorizar.
O pull request permite-nos rever quais as alterações que queremos incorporar no ramo principal, com que testes e com que recomendações do auditor.
Também convém verificar se a versão que vamos integrar continua a ser a que foi auditada. Se modificarmos o código depois de receber um GO, essa avaliação pode deixar de ser válida.
Prefiro manter autorizações explícitas para as operações importantes. Podemos agrupar algumas quando o âmbito é muito claro, mas não conceder liberdade ilimitada para integrar e publicar.
Uma coisa é o auditor considerar o desenvolvimento correto e outra é decidirmos incorporá-lo.
É aqui que poderia entrar a terceira IA: podemos acrescentar um segundo auditor especializado, como o CodeRabbit.
Ao contrário do Antigravity, que utilizamos para rever localmente o plano e o código, o CodeRabbit pode analisar automaticamente os pull requests do GitHub antes de serem integrados.
É uma revisão adicional interessante para projetos importantes, embora não seja imprescindível e tenha um custo, ainda que económico para tudo o que oferece. No meu caso, por enquanto prefiro manter as duas auditorias manuais e considerar esta terceira revisão quando o projeto for maior.
Passo 8. Publicar e verificar o funcionamento em produção
Este passo depende bastante de onde o projeto está alojado.
No primeiro artigo utilizámos o Railway. Também poderíamos publicar através do GitHub Actions, de ferramentas do nosso alojamento ou de qualquer outro sistema de publicação.
Veremos as particularidades do WordPress, do LocalWP e da Webempresa noutro artigo.
Aqui interessa-nos uma regra geral: uma publicação concluída com sucesso não significa que a funcionalidade esteja a funcionar bem.
Depois de publicar a alteração, temos de verificar a aplicação real.
No nosso exemplo, isso significa visitar as páginas públicas, verificar os artigos destacados, navegar pela listagem e garantir que não alterámos outras funcionalidades.
Também precisamos de confirmar que a nova versão está a ser apresentada. Por vezes o código é publicado corretamente, mas a cache continua a servir conteúdo antigo, como me aconteceu com o WP Rocket.
Em desenvolvimentos importantes, devemos prever como recuperar a versão estável se algo falhar.
Só depois destas verificações podemos afirmar que a funcionalidade está concluída.
Passo 9. Encerrar a tarefa e preparar o desenvolvimento seguinte
Depois de verificar o resultado, pedimos ao Codex que atualize o Linear e a documentação do projeto.
Deve registar o que foi desenvolvido, qual a versão publicada, que testes realizámos e se existe alguma ocorrência pendente.
A tarefa passa a concluída depois da verificação em produção, não quando o Codex termina de programar nem quando o Antigravity emite o seu GO.
Esta documentação tem outra vantagem: podemos encerrar a sessão e começar outra sem perder o contexto.
Aliás, recomendo fazê-lo quando começamos uma funcionalidade diferente. Os agentes podem recuperar as regras, os requisitos e as decisões nos documentos do projeto, em vez de dependerem de conversas intermináveis.
Com o tempo poderemos automatizar parte da coordenação entre o Codex e o Antigravity, embora, por enquanto, prefira mantê-la manual, verificar que o procedimento funciona e ganhar confiança antes de eliminar etapas de supervisão.
Vale a pena trabalhar assim em qualquer desenvolvimento?
Não.
Para criar um teste ou experimentar durante vinte minutos, preparar documentação, duas auditorias e um processo de publicação é excessivo.
Mas quando desenvolvemos um site real, uma aplicação para um cliente ou um projeto que vamos manter durante meses, esse trabalho adicional faz todo o sentido.
A vantagem deste procedimento não é eliminar erros nem substituir os conhecimentos de programação, mas permitir trabalhar de forma mais organizada, guardar as decisões e detetar problemas antes de chegarem aos utilizadores. Minimizamos os erros típicos do vibe coding inicial.
E, como a maior parte das tarefas operacionais é realizada pelos agentes, a nossa intervenção concentra-se no essencial: decidir o que queremos, aprovar como o vamos fazer e verificar que o resultado funciona.
Conclusão
No primeiro artigo preparámos o computador. Neste preparámos a nossa forma de trabalhar.
Agora sabemos como:
- Transformar uma necessidade em requisitos.
- Pedir um plano ao Codex.
- Auditá-lo com o Antigravity.
- Desenvolver uma funcionalidade.
- Rever o código.
- Publicá-lo com controlo de versões.
- Documentar tudo.
Não se trata simplesmente de programar mais depressa com inteligência artificial, mas de conseguir manter aquilo que desenvolvemos, compreender o que foi alterado e ter um procedimento para corrigir os problemas quando surgirem.
No próximo artigo aplicaremos esta forma de trabalhar ao WordPress: desenvolvimento local, testes, ficheiros sob controlo de versões e publicações num alojamento real.
Perguntas frequentes
Preciso de saber programar para utilizar este procedimento?
Não é indispensável escrever código, mas é preciso compreender os conceitos básicos do desenvolvimento e aprender a interpretar os testes e os riscos. A IA não elimina a nossa responsabilidade pelo resultado.
É obrigatório utilizar o Codex e o Antigravity?
Não. Podes substituí-los por outros agentes de programação e revisão. O importante é separar as funções e evitar que o programador seja o único a avaliar o próprio trabalho.
Preciso de Notion e Linear?
O Linear é a ferramenta de gestão de tarefas que utilizamos neste tutorial. O Notion é opcional para projetos simples, embora o recomende quando acumulamos requisitos, decisões e documentação. Uma alternativa é guardar essa informação em Markdown.
O que faço quando o Antigravity emite um NO-GO?
Transmite o relatório ao Codex, pede-lhe que corrija os problemas e repete a auditoria. Não avances automaticamente para a fase seguinte.
Porquê auditar duas vezes?
Porque a primeira auditoria procura problemas no plano e a segunda verifica a sua implementação. Rever apenas o código pode deixar passar erros de conceção que teriam sido mais fáceis de corrigir antes.
Posso utilizar esta forma de trabalhar com WordPress ou outras tecnologias?
Sim. O procedimento é independente da linguagem ou da plataforma. O que muda são os testes, os ambientes e os mecanismos de publicação.
Quando é que uma tarefa está realmente concluída?
Quando a versão autorizada está publicada, foi verificado que funciona em produção e as provas e decisões ficaram registadas.

Deixe um comentário