[🤖] Conectei o fluxo e o senso do meu trabalho com Codex Skills

✨ Resumo do GPT-5.6 Sol

Um registro de como preservei o fluxo fazendo Codex Skills relerem as regras e as evidências atuais, para levar diretamente à tarefa seguinte e à escrita o discernimento que eu acabara de formar ao configurar um servidor Linux.

Hoje eu estabeleci a base operacional de um servidor Linux dedicado aos serviços da empresa. Instalei o Ubuntu Server em um SSD novo, conectei-o por SSH na rede interna e projetei os limites entre usuários para que o administrador humano, as AI Cells e os Runtimes de automação do trabalho pudessem compartilhar um único servidor sem invadir as permissões nem o estado uns dos outros.

Documentei separadamente a estrutura específica de discos, rede e contas do servidor no texto linkado acima. O que quero registrar aqui não é o método de instalação, mas a experiência de terminar esse trabalho sem perder o fluxo do discernimento que o sustentava.

Depois de registrar em uma Skill de rede como o roteador, o NAS, o Runtime existente e o novo servidor Linux se conectavam, não precisei mais explicar toda a lista de equipamentos na session seguinte do Codex. Também separei o que já estava concluído do que ainda existia apenas como projeto. O senso operacional que eu havia desenvolvido enquanto trabalhava no servidor ficou em um estado que a tarefa seguinte podia herdar intacto.

Ótimo. Agora que me acostumei a usar Skills, consigo montar coisas assim rapidinho. Muito bom. Seja qual for o trabalho, parece mesmo importante manter o fluxo sem perder o senso do que se está fazendo.

O que me agradou naquele momento não foi apenas ter criado uma Skill rapidamente.

O senso operacional que acabara de surgir enquanto eu trabalhava no servidor passou para a estrutura de usuários; essa estrutura ficou registrada na Skill de rede e, depois, seguiu para o devlog que explicava o trabalho. Quando terminei de escrever, logo pensei em criar outra Skill que buscasse o trabalho recente nas conversas e no histórico do Git e o transformasse em uma entrada de diário.

Montar um servidor e criar uma Skill de escrita são tarefas completamente diferentes, mas, na minha cabeça, faziam parte do mesmo fluxo. No trabalho anterior, eu continuava pensando no que precisava ser deixado para que a tarefa seguinte não começasse do zero, e logo em seguida aplicava a resposta à estrutura da próxima ferramenta.

A nova Skill reutilizou o fluxo que eu já havia construído

Antes, eu tinha criado o gsheet-hour-blocks para gerar registros de trabalho por hora destinados à minha agenda pessoal. Em vez de resumir apenas a conversa atual, ele também lia o histórico do Git dos repositories relacionados e condensava o que eu realmente havia feito em frases para blocos de tempo.

Desta vez, só a saída era diferente.

A base para ler conversas recentes, commands, resultados de tools e evidências do Git de um período determinado já existia. A nova Skill não precisava extrair uma lista de tarefas dessas evidências, mas encontrar os problemas que eu realmente havia sentido e as mudanças no meu discernimento, e então escrevê-los como um diário independente de acordo com as regras atuais do blog.

Não havia necessidade de projetar tudo do zero. O método que eu havia aprendido antes virou material para o seguinte.

Também permanecia a experiência de transformar a pergunta que eu repetia sempre —“Você realmente fez isso com perfeição?”— em uma Skill chamada audit-and-fix-until-clean. Quando percebo uma exigência recorrente, em vez de escrever mais um prompt longo, consolido-a em uma forma de trabalho reutilizável com uma condição de encerramento. Depois de esbarrar algumas vezes no mesmo padrão, passei a enxergar muito mais rápido quais partes pertenciam a uma Skill e quais deveriam permanecer no project original.

Graças a esse senso de limite, a estrutura geral do blog-write-diary tomou forma rapidamente.

Mas o Codex seguiu uma direção errada uma vez.

Copiar as regras dividiria o contexto em vez de dar continuidade a ele

No início, ele tentou levar para a nova Skill as regras de categoria, estilo, data e tradução deste blog.

Não era isso que eu queria.

Não estou dizendo para copiar essas regras para dentro da Skill. Mais precisamente, quero que ela leia diretamente as regras e o contexto do project cdb. A migração das regras em si pode ficar para depois.

As regras do blog continuam mudando. Copiá-las para a Skill faria as mesmas regras existirem em dois lugares. Talvez funcionasse no começo, mas em algum momento as regras atuais do project e as regras antigas lembradas pela Skill iriam divergir. Um mecanismo feito para dar continuidade ao contexto acabaria fixando um contexto ultrapassado.

Por isso, fiz com que o blog-write-diary não fosse dono das regras do blog.

O que a Skill lembra é apenas o procedimento: em que ordem ler a conversa atual, os commands e as evidências do Git; como encontrar o centro que os conecta em um único fio; e que, antes de escrever o texto de fato, deve verificar novamente o AGENTS.md, as categorias e os textos vizinhos atuais do cdb.

As regras que mudam permanecem no project original, e a Skill retorna a essa source of truth sempre que é executada.

Essa diferença era o ponto central. Em vez de fazer a IA lembrar de todo o contexto por muito tempo, construí um caminho para que ela pudesse reentrar com precisão no contexto atual quando necessário.

O que seguiu adiante não foi o volume de informação, mas o discernimento

O context da IA é limitado. Conversas longas são comprimidas e, quando o trabalho passa para outra session, os julgamentos sutis da anterior desaparecem com facilidade. Mas também não posso preservar todas as conversas para sempre e fazer a IA reler tudo a cada vez.

Preservar toda a informação não era a parte importante.

Ao iniciar a tarefa seguinte, eu precisava conseguir reconstruir por que um limite era importante, o que já havia sido descartado, o que eu havia decidido proteger e em qual source deveria confiar agora. Com esse estado restaurado, a IA consegue continuar o julgamento anterior em vez de apenas imitar sua conclusão.

Comigo, como pessoa, acontecia o mesmo.

Hoje eu conseguia ver imediatamente por que as contas do servidor e os Runtimes precisavam ser separados, e por que as regras do project não deveriam ser copiadas para uma Skill. Os motivos dessas decisões ainda estavam quentes. Quando o tempo passa e resta apenas uma conclusão vaga, reler a mesma explicação não me traz de volta ao trabalho com o mesmo senso e a mesma rapidez.

Uma vez escrevi que a memória humana é comprimida e volta à vida por meio de pistas. Desta vez, transformei essa ideia em uma forma real de trabalhar.

Skills, AGENTS.md e o histórico do Git não são depósitos que preservam cada momento. São pistas que permitem à IA da session seguinte —e ao meu eu do futuro— reconstruir o julgamento necessário para reentrar no trabalho. Um caminho que me permite seguir novamente as sources e evidências atuais até uma conclusão foi mais útil do que uma única conclusão bem preservada.

Enquanto o senso está vivo, construo também a próxima parte do fluxo

O que tornou esta experiência prazerosa não foi apenas ter criado o blog-write-diary rapidamente.

O senso que adquiri ao montar o servidor Linux seguiu para a estrutura de usuários e para a Skill de rede. Esse julgamento operacional seguiu para o devlog, e o fluxo de escrever aquele texto levou ao projeto de uma nova Skill de diário. Em nenhum momento precisei voltar completamente ao início.

Era isso que me agradava.

Seja desenvolvendo ou escrevendo, passar à tarefa seguinte enquanto os julgamentos construídos na anterior ainda estão vivos faz mais do que aumentar a velocidade. Como não preciso vagar para redescobrir o que importa, o nível do resultado também segue adiante. Consigo explicar por que algo funciona e, quando vejo uma estrutura errada, consigo parar mais cedo.

A estrutura que criei para lidar com o context curto da IA também está compensando minha memória curta. Mas o fato de pessoas e IA esquecerem não é toda a conclusão deste texto.

O que quero continuar construindo se parece menos com um dispositivo de memória e mais com um dispositivo para reconectar o fluxo.

Para que, na próxima vez que eu começar, não precise explicar tudo do zero e lutar para recuperar o senso, mas possa dar o passo seguinte diretamente a partir do julgamento a que já cheguei.