Programação
Melhore uma ferramenta de testes de mutação com base no código e nos testes atuais
Para alterar uma ferramenta de testes de mutação. Confere primeiro o código e os testes atuais, preserva a ordem de processamento e a avaliação tardia, cria mutadores sem mutantes inválidos, escreve testes que os detectam e segue passos seguros de revisão, CI e lançamento.
Adicione recursos a um app desktop em camadas e teste cada compilação
Use quando uma IA alterar um app desktop dividido em núcleo, host desktop e interface Web. Mantém as regras no núcleo, limita os comandos e pastas das ferramentas, separa recursos opcionais pelas dependências reais e testa cada compilação compatível antes de concluir.
Encontrar bugs reais em patches de sistemas de baixo nível, sem implicar com estilo
Use ao revisar patches de sistemas de baixo nível, como drivers ou bibliotecas de rede. Segue memória, locks e caminhos de erro, verifica inteiros, threads, criptografia e mudanças de API e relata só problemas corrigíveis; estilo, só com muita certeza.
Adicione recursos a um serviço Go extensível com testes que resistam à sobrescrita da configuração
Para alterar um serviço Go que outras builds renomeiam ou personalizam. Mantém o contexto de rastreamento nos logs, registra novas ferramentas no grupo certo, testa o comportamento público com configuração sobrescrita e atualiza a documentação gerada.
Imite o comportamento de outro framework web com uma camada de compatibilidade
Use ao reimplementar outro framework web em vários ambientes. A IA porta primeiro os testes dele, respeita a ordem das solicitações e os limites entre ambientes, normaliza caminhos de arquivos e só faz merge por pull requests que passam em todas as verificações.
Alterar um wrapper gerenciado e sua biblioteca nativa sem quebrar a ABI
Use ao editar um wrapper gerenciado multiplataforma sobre uma biblioteca C nativa. Segue cada mudança pelas camadas, compila binários nativos do código-fonte em vez de downloads antigos, mantém a ABI pública estável, trata a posse de ponteiros e as threads e não pula testes que falham.
Adicione e teste kernels em uma biblioteca de kernels de GPU com compilação JIT
Use quando uma IA trabalhar em uma biblioteca de kernels de GPU compilados no uso (JIT). Adiciona kernels por todas as camadas, grava arquivos gerados só em pastas graváveis, testa por tipo de GPU e confere os resultados antes de medir a velocidade.
Altere e revise um gateway de integração multiprotocolo sem quebrar as verificações de acesso
Use quando uma IA alterar ou revisar um gateway que liga vários protocolos. Ela passa nas verificações do projeto, mantém as permissões rígidas, separa as gravações de rastreamento e auditoria, cuida das migrações e pede aprovação antes do push.
Criar serviços Rust assíncronos que resistam a cancelamentos e falhas
Para serviços Rust assíncronos: a IA conclui o código real sem simulações, trata erros e cancelamentos com segurança, testa pela interface real do serviço e passa em todas as verificações antes de dizer que terminou.
Altere uma biblioteca de dados multilíngue sem quebrar formatos de arquivo nem APIs
Use quando uma IA alterar uma biblioteca de dados rápida com núcleo nativo e vinculações leves para cada linguagem. Mantém compatíveis os formatos de arquivo estáveis e as APIs públicas, usa os comandos documentados e adiciona testes e documentação.
Criar código de replicação de dados (ETL) que não altere valores em silêncio nem vaze dados
Use ao criar ou alterar código que copia dados entre bancos de dados. A IA mantém as mudanças pequenas, evita arredondamentos e outras mudanças silenciosas, retorna erros claros para entradas ruins, não registra segredos nem linhas nos logs e confere se os testes rodaram.
Alterar uma ferramenta de automação de dispositivos e conferir em aparelhos reais
Use quando uma IA altera uma ferramenta multiplataforma de automação de dispositivos. Mantém as mudanças pequenas, reúne os comandos num registro, escolhe testes conforme a mudança e confere com builds novos em aparelhos reais ou simuladores antes de relatar.
Alterar um monorepositório grande e tipado sem quebrar outros pacotes
Use quando uma IA altera código com vários pacotes. Ela encontra o pacote responsável pela mudança, reutiliza utilitários compartilhados, segue as regras de construção e tipos, testa só os pacotes afetados e relata só as verificações realmente feitas.
Altere um mecanismo de armazenamento de banco de dados sem perder velocidade nem compatibilidade
Use quando uma IA alterar um mecanismo de armazenamento de banco de dados. Cuida dos erros e da concorrência, acelera o código mais executado só com testes comparativos, mantém compatíveis as API, os formatos e as compilações, e exige testes reproduzíveis antes de aprovar.
Desenvolver uma CLI multiplataforma em uma árvore de trabalho compartilhada sem estragar o trabalho alheio
Para criar uma CLI em uma árvore de trabalho compartilhada com outras sessões. Trabalha só na árvore atual, preserva as mudanças alheias, separa os dados das mensagens para pessoas, testa em todos os sistemas e mantém snapshots e documentação em dia.
Criar uma ferramenta de contêineres sem root, com bloqueios e downloads de imagens verificados
Use ao criar uma ferramenta de contêineres sem root. A IA bloqueia os contêineres durante mudanças, verifica cada camada de imagem baixada, não copia o ambiente do host, encerra árvores de processos inteiras e rejeita caminhos perigosos ao restaurar backups.
Crie uma ferramenta que revisa e corrige código com IA sem perder o código do usuário
Use ao trabalhar em uma ferramenta que revisa e corrige código com IA em segundo plano. Lê antes a build e os documentos de responsáveis, impede que branches não confiáveis rodem comandos, protege jobs ativos e barra pushes ou releases inseguros.
Escrever habilidades para agentes de IA e testar se elas realmente ajudam
Para adicionar ou atualizar habilidades em uma biblioteca de habilidades para agentes de IA. Cobre nomes e versões, descrições que são acionadas na hora certa, permissões mínimas de ferramentas, testes com e sem a habilidade e verificações antes de publicar.
Fazer alterações pequenas e testadas no monorrepositório de um framework
Use quando uma IA altera código no monorrepositório de um framework. Procura primeiro os arquivos de orientação principais, limita cada alteração a um comportamento, escreve um teste que falha antes de corrigir e verifica segurança, compilação e notas de lançamento.
Alterar um grande monorrepositório de fluxos de trabalho em Python sem quebrá-lo
Use quando uma IA altera um grande monorrepositório Python de fluxos de trabalho. Separa os papéis do agendador, dos processos de trabalho e do banco de dados, põe cada dependência no pacote certo, testa primeiro o que mudou e revisa o diff completo antes da solicitação de integração.
Alterar juntas as versões síncrona e assíncrona de uma biblioteca cliente sem quebrar a API
Use quando uma IA alterar uma biblioteca cliente com versões síncrona e assíncrona. Mantém as APIs públicas e os erros, aplica a mesma mudança nos dois lados, não deixa os caminhos críticos mais lentos e testa de um caso com falha até a matriz completa.
Criar um serviço de memória para agentes de IA sem misturar as memórias de cada usuário
Use ao criar ou ampliar a memória de longo prazo de agentes de IA. Mantém cada banco de memória separado, distingue ingestão, recuperação e raciocínio, e cobre migrações de banco de dados, clientes de API, testes julgados por outro modelo e configurações por inquilino ou banco.
Alterar o monorepositório de uma plataforma distribuída de trabalhos e testá-lo com serviços reais
Use quando uma IA alterar um monorepositório de trabalhos distribuídos. Ela escolhe a verificação certa para cada pacote, testa com bancos de dados e filas reais, registra as alterações publicadas, executa localmente uma tarefa completa e informa o que verificou e o que omitiu.
Criar módulos .NET com design orientado a domínio (DDD) sem quebrar camadas nem APIs públicas
Use quando uma IA alterar um app .NET modular com design orientado a domínio. Ela segue os padrões existentes, mantém as camadas em um só sentido, coloca agregados, repositórios e DTOs na camada certa e testa em todos os bancos de dados sem afetar quem já usa.
Alterar uma extensão para vários navegadores sem vazar segredos nem quebrar os dados salvos
Use ao alterar uma extensão publicada para vários navegadores. Mantém segredos localmente, regenera as políticas de dependências, adiciona atualizações numeradas para dados salvos, testa na camada certa e usa o Git só quando pedido.
Alterar código distribuído de treinamento e inferência de aprendizado de máquina sem quebrá-lo
Use ao mudar software que treina ou executa modelos de aprendizado de máquina em muitos processos ou aceleradores. Consulta antes de mudanças arriscadas, alinha versões de pesos e a ordem das operações coletivas em cada rank, mantém a configuração compatível e informa os testes pulados.
Desenvolver um app web que mostra logs e métricas de contêineres ao vivo
Use ao alterar uma aplicação com backend e frontend que transmite logs e métricas de contêineres ao vivo. Respeita as camadas, os limites de streaming e os modos de login e implantação, adiciona recursos em todas as camadas, roda os testes e escreve revisões curtas.
Alterar um pacote de servidor público que outros estendem sem quebrar o código deles
Use ao alterar um pacote de servidor publicado que outros estendem com hooks. A IA deixa segredos de fora, mantém callbacks, hooks e a ordem do middleware, adiciona migrações novas em vez de editar as antigas e roda os testes e o lint reais do pacote.
Altere um projeto C portátil e antigo sem quebrar a compatibilidade
Use se uma IA alterar código C maduro que precisa continuar compilando em compiladores antigos, muitas plataformas e recursos opcionais. Compila e testa o que foi afetado, segue as regras de estilo, memória, commits, documentação e versões, e deixa cada patch pequeno e válido por si só.
Alterar um repositório de backend e frontend com vários módulos sem quebrar a compilação
Use quando uma IA for alterar um repositório que reúne API, backend e frontend. Ela lê as regras de cada módulo, mantém os dois lados alinhados, regenera o cliente da API em vez de editá-lo à mão, roda os testes certos e pergunta antes de migrações ou novas dependências.
Altere um grande monorepositório de plataforma de dados multilíngue e prepare pull requests
Use quando uma IA editar uma grande plataforma de dados em várias linguagens. Ela escolhe o branch Git certo, não edita à mão arquivos gerados, usa a menor base de teste, testa só o que mudou, verifica cada falha da CI e pede permissão antes de fazer push ou abrir pull requests.
Criar e revisar automação de infraestrutura com Ansible sem enfraquecer a segurança
Use quando uma IA escrever ou alterar automação de infraestrutura com Ansible. Ela passa em todos os lint e verificações de segurança sem avisos, mantém segredos fora do repositório, investiga a rede de baixo para cima, prova que os testes detectam a falha e relata só o que executou.
Alterar um grande sistema de dados em Python sem quebrar a execução preguiçosa
Use quando uma IA alterar um grande sistema de dados ou de computação paralela em Python. Mapeia primeiro as camadas, não executa cálculos ao montar grafos, testa do mais próximo para o mais amplo e nunca lança versões nem publica pacotes sem permissão.
Escrever primeiro a especificação e depois programar em pequenos passos com testes primeiro
Use quando uma IA programar a partir de pedidos vagos em um repositório com especificações e planos. Registra as dúvidas e espera respostas, atualiza especificação e plano, escreve antes testes que falham, verifica arquivos alterados, protege o banco de dados e deixa uma passagem clara.
Criar Regras de um Verificador de Acessibilidade que Retornem Aprovado, Falha ou Incompleto
Para quando uma IA adiciona ou altera regras em um verificador de acessibilidade web. Separa as camadas de DOM e de dependências, lê os dados de HTML e ARIA de um só lugar, testa em páginas realistas com Shadow DOM, sincroniza as traduções e evita mudanças incompatíveis.
Gerar esquemas de comandos para agentes de IA a partir dos comandos e flags reais
Use ao criar os esquemas que dizem aos agentes de IA quais comandos existem e como chamá-los. A IA os gera em um só sentido a partir de uma lista revisada e dos comandos reais, e verifica a cobertura, os exemplos e a segurança e confirmação.
Faça mudanças pequenas e compatíveis em um projeto Java dividido em módulos
Para quando uma IA altera um projeto Java dividido em módulos. Confere primeiro as regras de build e CI, mantém funcionando versões antigas do Java e as dependências entre módulos, testa na camada certa e pergunta antes de mudanças amplas ou arriscadas.
Adicionar recursos a uma biblioteca multilíngue de infraestrutura como código sem quebrar os usuários atuais
Use ao alterar uma biblioteca tipada de IaC que gera bindings para outras linguagens. Põe cada recurso na camada certa, evita sintaxe que os bindings não suportam, protege mudanças com sinalizadores de recurso, mantém permissões estreitas e adiciona documentação e testes.
Adicione módulos a um servidor Go sem enfraquecer a segurança
Para criar ou revisar funcionalidades de um servidor Go extensível. A IA escreve cada módulo em ordem, da criação à limpeza, lê a configuração com rigor, passa em testes, lint e compilação no Linux, macOS e Windows antes da mesclagem e deixa pull requests para uma pessoa.
Crie um app TypeScript para nativo e web seguindo as regras do repositório
Use ao criar ou alterar um app TypeScript que roda em nativo e web. A IA segue os scripts e a estrutura de pastas do repositório, reaproveita os componentes compartilhados, prepara os textos da tela para tradução e testa cada plataforma afetada antes de terminar.
Alterar um repositório de aplicação completa sem quebrar a compatibilidade
Use quando uma IA alterar um repositório de aplicação completa. Lê primeiro as orientações, mantém compatíveis as chaves do banco de dados, as migrações e os campos da API, usa os componentes compartilhados e os arquivos de tradução, e relata só o que de fato executou.
Corrija testes E2E que falham observando o navegador real
Use quando um teste E2E falhar. Define o estado de sucesso visível, roda o teste num navegador real, reúne capturas de tela e erros do console, classifica a causa em teste, código ou ambiente, faz a menor correção e repete até passar ou precisar parar.
Crie um serviço de agentes de programação que recebe pedidos do chat e do sistema de chamados
Para um serviço cujos agentes de programação recebem trabalho da hospedagem de código, do sistema de chamados e do chat. Separa as funções principal, revisora e analisadora, usa um ambiente isolado por thread, fixa a ordem das camadas intermediárias e deixa ligar o reparo automático de CI.
Alterar uma API em Go e uma SPA em React editando primeiro a especificação OpenAPI
Para repositórios onde um backend em Go e uma SPA em React compartilham uma especificação OpenAPI. Muda a especificação e regenera o código sem mexer no que é gerado, segue regras para configurações, erros, sessões, downloads e atualizações, e testa antes de relatar.
Crie ou altere componentes em uma biblioteca de componentes de UI com temas
Use quando uma IA adicionar ou alterar um componente em uma biblioteca de UI reutilizável. Localiza os arquivos afetados, mantém os padrões do tema, a acessibilidade e o layout da direita para a esquerda, e adiciona testes e documentação.
Transformar uma ideia de software em um sistema multiagente testado
Para criar um sistema em que vários agentes de IA e ferramentas trabalham juntos. Faz uma pergunta por vez, pede sua aprovação do desenho de papéis e comunicação, constrói na ordem das dependências e repete 5 cenários de usuário até passarem.
Altere um monorepo TypeScript full-stack e teste as funcionalidades de LLM pelo significado
Para uma IA que altera um monorepo TypeScript com funcionalidades de LLM. Roda só as verificações por pacote da CI, testa o comportamento, não deixa dados pessoais em logs amplos e avalia as respostas do LLM pelo significado, não pelas palavras.
Crie uma aplicação TypeScript full-stack com esquemas de API compartilhados entre servidor e cliente
Use ao criar ou alterar uma aplicação TypeScript full-stack. A IA define uma única vez cada requisição e resposta da API para rotas e hooks do cliente, verifica a autenticação antes de ler a entrada, mantém consistentes dependências, cache e estilos, e escreve testes rápidos.
Faça mudanças em um monorepo full-stack sem quebrar os pacotes compartilhados
Use quando uma IA edita um monorepo com apps e pacotes compartilhados. Coloca cada mudança no módulo certo, recompila os bundles gerados, não mistura os dados de cada organização e entrega um pull request com resultados de testes.
Alterar o código de um banco de dados de alto desempenho sem perder velocidade nem compatibilidade
Use quando uma IA altera um banco de dados focado em velocidade que envolve Java, SQL, Rust, código nativo e CI. Define regras de estilo, NULL, liberação de memória, testes de consultas, falhas, pull requests e build, e termina com uma checagem antes de dar o trabalho como concluído.
Alterar um app de treinamento em segurança com falhas intencionais sem quebrar seus desafios
Use ao editar um app de treinamento cujas vulnerabilidades são lições. Separa desafios intencionais de falhas acidentais, mantém mudanças pequenas, tira o excesso gerado por IA, roda os testes exigidos e a rede de segurança dos desafios, e mantém os arquivos de correção sincronizados.
Altere um mecanismo de banco de dados analítico em C++ e passe nos testes
Use ao mudar o código de um mecanismo de banco de dados analítico em C++. A IA segue a mudança da análise do SQL até a execução, edita os arquivos gerados pelo código-fonte, segue as regras de C++ e de erros, e só termina após passar nos testes de lógica SQL e nas compilações necessárias.
Corrigir um defeito reproduzindo-o primeiro com um teste que falha
Use quando um defeito for relatado. A IA decide a qual parte ele pertence, reproduz o que o usuário vê em um teste que falha, encontra a causa real, aplica a menor correção, mantém o teste para que não volte e repete os passos do usuário para confirmar.
Criar uma biblioteca que leia e grave arquivos de imagem em camadas sem perder dados
Use ao criar uma biblioteca para imagens em camadas em formato binário. Separa a leitura binária da API do usuário, lê as seções em ordem, guarda dados desconhecidos, refaz os grupos de camadas, testa lendo, gravando e relendo, e automatiza a publicação.
Escrever e revisar documentação de segurança para desenvolvedores
Use ao escrever ou revisar documentação de segurança para desenvolvedores em um repositório compartilhado. Cita só fontes que leu, diz o que cada medida impede e o que não impede, mantém as mudanças pequenas, executa as verificações do repositório e declara o uso de IA.
Faça alterações pequenas e testadas em um grande monorepositório TypeScript
Use quando uma IA altera um espaço de trabalho TypeScript com muitos pacotes. Primeiro ela conhece a estrutura e as ferramentas do repositório, executa só as compilações e os testes afetados, não mexe nos arquivos gerados sem motivo e confere se tudo funciona no Unix e no Windows.
Altere um monorepositório com várias implementações sem deixá-las divergir
Use ao alterar um grande monorepositório multilíngue em que um produto tem várias implementações. A IA lê as regras locais, leva as mudanças visíveis a todas, recompila o que os testes usam, faz testes direcionados, adiciona o registro de lançamento e atualiza a solicitação de alteração.
Fazer mudanças pequenas em uma biblioteca de interface com estado sem quebrar quem a usa
Use quando uma IA altera uma biblioteca de interface para navegador que guarda estado. Encontra o dono do estado, mantém compatíveis as APIs públicas e os dados salvos, escreve antes um teste que falha, escolhe o tipo de teste e revisa as diferenças e a nota de lançamento.
Criar um emulador local de nuvem que funcione com os SDKs e CLIs oficiais
Use ao adicionar serviços ou operações a um emulador que imita a nuvem no seu computador. Confirma o protocolo real, mantém requisições e respostas como na nuvem real, atualiza armazenamento e configuração juntos e testa com os SDKs oficiais antes do lançamento.
Crie um emulador que reproduza o barramento e a temporização do hardware real
Use ao criar ou corrigir um emulador. Divide o código por partes do hardware, copia o barramento, a temporização e o DMA do hardware real, testa com programas que passam no aparelho real e mantém estáveis os estados salvos e a API pública.
Fazer pequenas alterações no código que passem em testes locais e revisão
Use quando uma IA alterar o seu código. Ela combina antes o que vai mudar e como comprovar, roda testes locais antes e depois, submete as alterações atuais à revisão, corrige só os problemas reais e termina com um relatório para outro agente continuar.
Altere um monorrepositório de automação multilíngue sem quebrar a compatibilidade
Para quando uma IA altera um grande monorrepositório de automação com vinculações em várias linguagens. Mantém as APIs públicas compatíveis, compila e testa só o menor alvo afetado, verifica se outra vinculação age igual e pergunta antes de mexer em áreas compartilhadas de alto risco.
Manter backend e frontend de um app de geração sincronizados via OpenAPI
Use ao mudar um app em que itens são extraídos, confirmados numa página de preparação e gerados num espaço de geração. Regenera os tipos do OpenAPI após cada mudança de API, separa as funções de cada tela e os tipos de estado, e mantém a documentação e as notas de versão atualizadas.
Alterar e testar código em um monorrepositório grande com muitos pacotes
Use quando uma IA trabalha em um grande repositório de framework com muitos pacotes. Ela mapeia a estrutura antes de editar, mantém a compilação atualizada, escolhe testes conforme o modo da CI, corrige falhas da CI antes da revisão, mantém segredos fora dos logs e confere cada alteração.
Faça mudanças pequenas em uma biblioteca de baixo nível sem quebrar a API pública
Use quando uma IA corrigir ou alterar uma biblioteca de sistema de baixo nível. Faz mudanças pequenas, não mexe na API nem na ABI públicas sem pedido, compila e testa o subsistema afetado, falha com segurança em erros de memória e nunca faz push.
Alterar uma base de código com vários pacotes sem quebrar o que já funciona
Use quando uma IA editar um repositório com vários pacotes. Ela descobre o pacote responsável e suas regras, mantém o comportamento e os nomes públicos atuais, adiciona testes e documentação, pede aprovação para novas dependências e informa o que foi verificado e os riscos que restam.
Escreva regras de análise estática com correções automáticas que não mudam como o código roda
Use ao criar uma regra de análise estática (lint). Mira os padrões comuns, reutiliza os helpers existentes, só oferece correção automática quando é segura, testa sintaxe delicada e regenera a documentação em vez de editá-la à mão.
Desenvolva um framework de fluxos de dados em Rust para robótica e IA escolhendo os testes conforme a mudança
Use quando uma IA trabalhar em um framework de fluxos de dados em Rust para robótica e IA. Ela mantém claras as regras de mensagens, passa nas verificações antes de cada commit, escolhe testes profundos pelo risco e informa quais testes rodaram.
Ao alterar o back-end, bloqueie ataques vindos de uploads e entradas do usuário
Use quando uma IA alterar código de back-end que lida com uploads, pacotes compactados ou dados de solicitações. Ela rastreia os dados externos, valida antes do uso, corrige todos os caminhos de código parecidos e termina com uma checklist de segurança, lint e testes aprovados.
Desenvolva uma plataforma de automação multi-tenant sem misturar tenants ou edições
Para programar uma plataforma de automação multi-tenant com edições comunitária, empresarial e hospedada. Limita cada consulta ao seu projeto, usa o cliente seguro no HTTP de saída contra SSRF, declara cada dependência onde é usada e testa todas as edições.
Criar e alterar máquinas de estados orientadas a eventos sem quebrar seu comportamento
Para bibliotecas de máquinas de estados. A IA conclui cada evento antes do próximo, trata erros sem pular a limpeza, protege threads e máquinas filhas, escreve testes primeiro para mecanismos síncronos e assíncronos e alinha código, documentação e esquemas.
Alterar código em um repositório grande com várias linguagens compilando e testando só o necessário
Use ao alterar código em um repositório grande com várias linguagens. A IA estuda código parecido, verifica as ferramentas e o hardware disponíveis, roda só as compilações e testes afetados, restaura a CI completa antes da mesclagem e relata o que não foi verificado.
Altere uma CLI de desenvolvimento web feita de JavaScript e código nativo na camada certa
Use ao alterar uma CLI de desenvolvimento web que mistura JavaScript e código nativo. Encontra a camada dona do comportamento, confere os caminhos de comando global e local e escolhe os testes conforme o tipo de alteração.
Crie um sistema que lê documentos enviados e permite que agentes de IA os pesquisem
Para criar um serviço que recebe PDFs e outros arquivos para busca com IA. Envia cada arquivo a um analisador adequado, mantém títulos e tabelas, salva trechos em formato fixo e busca dentro de um orçamento, retornando evidências com citações.
Desenvolver software de recuperação sem conexão que divide um segredo em fragmentos
Para software que reparte um segredo entre pessoas de confiança e o recupera sem conexão. Rastreia cada mudança, compartilha o núcleo criptográfico entre CLI e navegador, mantém os pacotes sem conexão, testa primeiro e escreve textos calmos e claros para pessoas sob pressão.
Desenvolver um framework que oferece uma única API em várias linguagens de programação
Para criar um framework que gera pacotes para várias linguagens a partir de um só código. Define regras para o protocolo JSON entre processos, os tipos exportáveis, a geração de código e os testes que conferem se todas as linguagens se comportam igual.
Criar um agente de IA que investiga com ferramentas e testar que ele não chuta respostas
Para um agente de IA que investiga problemas chamando ferramentas. As ferramentas são só de leitura por padrão, devolvem dados limitados e explicam falhas com exatidão; nomes antigos de configuração continuam valendo, e os testes pedem fatos que só se acham consultando.
Prepare contribuições de código para uma pessoa revisar e enviar
Use quando uma IA trabalhar em um repositório de código compartilhado. Segue as regras do projeto, espera a aprovação dos mantenedores, não põe segredos em commits nem testes e deixa os pull requests em rascunho para uma pessoa enviar.
Adicione provedores de IA e bancos vetoriais a um framework modular de IA em Rust
Use ao ampliar um framework Rust que funciona com muitos provedores de IA. A IA segue os traits e builders existentes, mantém o suporte a WebAssembly, faz os hooks agirem igual com e sem streaming e confere se os cassettes gravados não têm chaves de API.
Adicionar uma ferramenta CLI a um downloader multiplataforma e verificar cada binário
Use ao adicionar ou revisar uma ferramenta de linha de comando em um instalador que baixa binários publicados. Levanta os arquivos de cada sistema e arquitetura, mapeia as URLs, testa com versão fixa, inspeciona cada binário e atualiza o catálogo e o PR.
Modificar um kit de UI para console seguindo a documentação atual e conferir a tela real
Para um kit de UI para console após uma grande reescrita: a IA segue a documentação atual do repositório em vez de hábitos antigos, coloca os testes no lugar certo e grava o terminal em execução para conferir as mudanças de UI.
Alterar uma grande base de código .NET mantendo-a rápida e compatível
Use ao editar um grande repositório .NET de alto desempenho, como um motor de compilação. Evita alocações extras nos caminhos críticos, trata todo aviso novo como mudança incompatível, compila a partir do menor projeto e informa quais compilações, testes e exemplos foram executados.
Altere um workspace Rust de bibliotecas e CLI e compare com a ferramenta de referência
Para mudanças de uma IA em um workspace Rust com bibliotecas e ferramentas CLI. Começa com um teste que falha, compara os resultados com a ferramenta de referência, evita unwrap() e testa cada combinação de funcionalidades.
Desenvolver automação de interfaces móveis e corrigir falhas no produto, não na CI
Para desenvolver com IA uma estrutura de automação de interfaces móveis. Põe cada mudança no seu módulo, escolhe a camada de teste mais barata, separa as suítes que devem passar das que devem falhar e corrige as falhas no produto, não na CI.
Crie uma ferramenta local de grafo de código que agentes de IA possam consultar
Use ao criar uma ferramenta que transforma uma base de código em um grafo local para agentes de IA. Abrange extrair símbolos e relações da árvore de sintaxe, instalar e desinstalar em vários clientes, dar respostas úteis aos agentes, testar em repositórios reais e publicar versões.
Desenvolver um gerenciador de cadeia de ferramentas multiplataforma e avaliar o que entra no seu registro
Use quando um agente de IA trabalhar em um gerenciador de versões de ferramentas. Segue as tarefas e os módulos do repositório, pede evidências de popularidade antes de incluir uma ferramenta no registro, deixa a ordem das versões a cada backend e roda testes direcionados por plataforma.
Altere um repositório com vários módulos e código gerado sem passar do que foi aprovado
Para quando uma IA trabalha em um repositório com vários módulos e código gerado. Lê primeiro as regras locais, altera a especificação e não os arquivos gerados, faz mudanças pequenas e compatíveis testadas por módulo e deixa lançamentos e pipelines a pessoas autorizadas.
Alterar e testar um grande repositório TypeScript que avalia modelos de IA
Use quando um agente de IA trabalha em um grande repositório TypeScript com CLI, web e avaliação de modelos de IA. Lê as regras locais, testa as alterações na CLI ou no navegador reais, depura sem apagar caches nem dados, integra por branches e CI e revisa a segurança primeiro.
Altere um monorepositório tipado sem quebrá-lo e mantenha sua wiki atualizada
Use quando uma IA trabalha em um monorepositório tipado grande com uma wiki do projeto. Ela usa os comandos do repositório, evita arquivos de build antigos e problemas com snapshots de inicialização, roda os testes necessários e atualiza a wiki com os arquivos de origem.
Altere um proxy reverso em Rust sem quebrar o loop de eventos nem a segurança
Use quando uma IA alterar, testar ou lançar um proxy Rust multiprocessos. Define regras para build e feature flags, erros e registros, loop de eventos e protocolo, testes e fuzzing, código sensível à segurança, pull requests e lançamento.
Mude um grande monorepo de plataforma e mantenha todos os clientes afetados em sincronia
Para mudanças de uma IA em um monorepo com CLI, bibliotecas cliente e documentação. Lê primeiro as regras de cada área, gera de novo os arquivos a partir das fontes, pergunta antes de mudanças incompatíveis e informa quais verificações rodaram.
Envie solicitações de incorporação feitas por IA a um framework de código aberto com revisão humana
Use quando uma IA contribui com código para um framework Java de código aberto. Marca o trabalho da IA, lê o histórico antes de corrigir, tira pausas fixas dos testes, segue o modelo de confiança do projeto e só incorpora com aprovação humana.
Adicione provedores e modelos de IA a um catálogo validado por esquemas
Use quando uma IA adicionar ou revisar um catálogo de provedores e modelos de IA. Roda o validador do repositório, herda dados comuns em vez de copiá-los, registra só opções de raciocínio e preços verificados e mantém as citações após a sincronização.
Altere um grande repositório de código nativo com compilações lentas sem quebrar as chamadas entre linguagens
Use ao alterar um grande repositório com linguagens nativas, vínculos gerados e compilações lentas. Ajusta o processo ao tamanho da mudança, começa pelo menor teste, salva uma vez os logs longos e protege as chamadas entre linguagens.
Crie um extrator do conteúdo principal de páginas web e depure o conteúdo perdido
Use ao criar ou corrigir um extrator do texto principal de páginas web para navegador, servidor, CLI ou edge. A IA mantém a ordem da limpeza, registra cada remoção, bloqueia a injeção de scripts e comprova cada correção com um teste que falha primeiro.
Altere uma biblioteca Go pública sem quebrar o código de quem a usa
Use ao alterar uma biblioteca Go pública. A IA verifica primeiro as versões de Go suportadas e as ramificações, testa com as ferramentas do projeto, segue os padrões de API existentes e prepara um pull request com os resultados dos testes e o impacto na compatibilidade.
Criar uma CLI local que busca seus documentos por palavra-chave e por significado
Use ao criar ou manter uma ferramenta de linha de comando que busca documentos no seu computador. Cobre coleções e notas de contexto, busca por palavra-chave e vetorial, limites de resultados, uso como serviço, testes e publicação, e deixa para o usuário as alterações do índice.
Criar habilidades de agente a partir da documentação de um projeto e mantê-las atualizadas
Use ao criar habilidades para um agente de IA a partir da documentação de um projeto ou das que a origem já publica. Separa habilidades geradas, sincronizadas e escritas à mão, escreve um índice curto e referências de um só tema, e atualiza só o que mudou desde a revisão registrada.
Criar uma biblioteca de dados com APIs fáceis de encontrar e testes com valores reais
Use ao criar ou alterar uma biblioteca que transforma dados complexos em objetos simples. A IA revisa o código antes de editar, registra o trabalho em tarefas e exige em cada recurso novo um teste com valores reais, um exemplo documentado executável e erros claros.
Alterar código em um repositório com vários pacotes e abrir PR só pelo seu fork
Use quando uma IA edita um repositório com vários pacotes e upstream somente leitura. Segue as instruções de cada pasta, envia só para o seu fork, preserva suas alterações sem commit, marca quem escreveu cada teste Python e relata com checagens que rodaram de fato.
Criar memória de longo prazo para agentes de IA com busca em grafos e vetores
Use para que agentes de IA guardem conhecimento entre sessões. Converte arquivos, URLs e texto em dados de grafos e vetores pesquisáveis, separa os dados de cada usuário com autenticação e permite trocar o armazenamento e os provedores de modelos sem mudar o código central.
Altere um serviço de autorização baseado em grafos escrevendo os testes primeiro
Use ao alterar um serviço de autorização baseado em grafos. Rastreia o caminho de cada requisição, usa os alvos de build e as regras de lint do repositório, escreve primeiro um teste que falha e não edita à mão os arquivos gerados.
Altere um framework web com segurança de tipos e separe o código de banco de dados em três camadas
Use ao alterar um framework web com segurança de tipos e vários pacotes. Trabalha no ambiente fixado, testa rápido e depois por completo, mantém pequenos os módulos públicos, separa em camadas o acesso ao banco de dados e nunca faz force-push.
Mantenha documentos de habilidades de IA em um só lugar e escreva-os para a IA consultar
Para manter documentos de habilidades de IA. Mantém um arquivo-fonte e regenera as cópias a partir dele, coloca as tabelas de decisão primeiro e os detalhes em referências, testa o comportamento antes e depois das mudanças e deixa a versão para o lançamento automático.
Amplie um compilador SQL com vários dialetos sem mudar o significado das consultas
Use ao alterar um compilador SQL que transforma SQL em uma AST e o gera para outros bancos de dados. Ele acha primeiro a camada responsável, mantém o significado entre dialetos, monta o SQL com auxiliares da AST em vez de strings e testa a execução real e a velocidade.
Escrever e publicar habilidades de agente que sejam acionadas certo e passem na validação
Para um repositório de habilidades de agente: a IA escreve descrições curtas sobre o que a habilidade faz e quando usá-la, mantém o arquivo principal curto com referências à parte, sincroniza versões e documentação e roda os validadores antes de publicar.
Executar uma ferramenta CLI complexa a partir de scripts e confirmar o sucesso no relatório JSON
Use quando um script ou agente de programação roda uma CLI complexa. Confere antes tarefas e classes, para se faltar a licença exigida, fixa entradas e dispositivo e julga o sucesso pelo código de saída e pelo relatório JSON, não pelo progresso.
Adicionar extensões de arquivo ou novas linguagens a um repositório de detecção de linguagens
Use quando uma IA adicionar extensões ou linguagens a um detector de linguagens. Adiciona amostras de código real e regras testadas para extensões compartilhadas, usa os scripts do repositório para o que é gerado e confere uso e licenças antes do envio.
Editar um gerador de documentos com agentes de IA sem confundir a pilha atual e a legada
Use quando uma IA alterar um app multiagente que gera documentos e ainda tem uma pilha antiga. Acha o comando de início real, confia no código mais que em documentos velhos, mantém os nomes de configuração, segue as mudanças entre Python e Node e roda os menores testes úteis.
Adicione módulos a um serviço de rede modular sem quebrar seus limites
Use quando uma IA alterar ou ampliar um serviço de rede feito de módulos. Liga os módulos só por interfaces compartilhadas, usa a compilação e os testes do repositório, retorna erros seguros para o cliente e não compartilha estado entre requisições.
Alterar um monorepo auto-hospedado de automação de certificados sem expor segredos
Use quando uma IA alterar uma ferramenta auto-hospedada que pede, renova e implanta certificados via ACME. Põe cada mudança no pacote ou plugin certo, escreve testes primeiro, adiciona migrações SQL, segue os padrões de UI e mantém certificados e chaves fora do código e dos logs.
Corrija e teste um gerador de wrappers de bibliotecas nativas para muitas linguagens
Use ao alterar uma ferramenta que gera wrappers de bibliotecas nativas para muitas linguagens. Procura a etapa onde o erro começa, roda testes do tamanho certo, adiciona testes de regressão e atualiza o registro de alterações.
Criar um repositório de habilidades de agentes de IA que avaliam a qualidade de sites
Para adicionar ou editar habilidades que avaliam velocidade, acessibilidade e SEO de sites. Define formato e nomes do SKILL.md, arquivos curtos, exemplos de antes e depois, scripts de shell que param em erros e uma ordem de problemas por impacto no usuário.
Alterar um repositório full-stack usando os comandos e testes dele
Use quando uma IA editar um repositório com frontend, API, SDK, CLI e banco de dados. Ela usa os comandos e versões fixadas do repositório, separa o papel de cada camada, testa na camada certa, verifica as páginas alteradas e as APIs com login e relata as evidências.
Desenvolva funcionalidades a partir de especificações aprovadas antes de programar
Use quando uma IA cria software por etapas a partir de especificações. Separa as diretrizes do projeto de cada especificação, escreve requisitos, design e tarefas em ordem com aprovação humana, pede uma revisão independente e confirma a conclusão com evidências novas.
Escreva regras em um repositório de regras de frontend e verifique-as antes de publicar
Use quando uma IA edita um repositório de regras de frontend (acessibilidade, desempenho, SEO, segurança). Define os metadados de cada regra, a ordem das seções e limites mensuráveis, mantém a interface compartilhada no sistema de design e roda todas as verificações antes de publicar.
Faça um agente de codificação de IA entregar código sem avisos e relatórios honestos em um repositório com build rígido
Use quando um agente de codificação de IA trabalhar em um repositório com verificações rígidas de build. Ele compila e valida antes de cada push, segue as regras de commit, escreve código seguro e confere cada afirmação no código.
Corrija a causa raiz em uma base de código grande e mantenha a API pública compatível
Use quando uma IA alterar uma base de código grande e em camadas. Mantém curtos os logs de build, rastreia os bugs até a causa de origem, revisa o próprio diff em busca de helpers que só escondem problemas e escreve um pull request claro.
Manter uma base de código grande e modular fácil de ler e de alterar sem quebrar
Use quando uma IA trabalha em uma base de código grande dividida em muitos componentes. Dá regras de estilo de código, tamanho de arquivos e de mudanças, revisão de código, testes, nomes da API e builds, para que as mudanças fiquem pequenas, legíveis e não quebrem outras partes.
Faça a IA mudar só o código necessário e perguntar antes do que é arriscado
Use quando um agente de IA edita o código do seu projeto. Define primeiro o escopo, adiciona só código útil e testes que pegam bugs reais, pede confirmação antes de apagar arquivos, fazer push ou chamar APIs de produção e informa os arquivos alterados e as verificações.
Faça mudanças testadas e prontas para revisão em uma base de código grande
Use quando um agente de IA altera uma base de código grande e multilíngue. Ele compila pelo wrapper do projeto, coloca os testes junto ao código e confirma que falham sem a mudança, segue as regras de revisão e relata só o que realmente executou.
Faça só as alterações pedidas em um repositório existente e pergunte quando houver dúvida
Use quando um agente de IA altera código existente. Ele pergunta quando tem dúvida, muda só o que foi pedido, roda os testes da área alterada e depois a suíte completa antes de dar como verificado, e não faz commit, push nem release sem pedido.
Envie mudanças pequenas e combinadas para uma base de código compartilhada
Use quando um agente de IA alterar uma base de código compartilhada, como uma biblioteca open source. Lê a issue, pergunta o escopo, ajuda com uma issue ou proposta se não há acordo dos mantenedores, faz correções pequenas com testes e docs e segue as regras de PR do projeto.
Fazer um agente de codificação com IA seguir as regras de branch e commit sem quebrar releases
Use quando um agente de codificação com IA trabalha em um repositório versionado. Define como criar branches, testar, fazer commits e guardar arquivos temporários, e como escrever instruções de agente que funcionem em diferentes ferramentas de IA, sem quebrar releases.
Manter uma biblioteca de UI multiplataforma sem quebrar suas camadas de pacotes
Para uma biblioteca de UI dividida em pacotes por camadas para várias plataformas: a IA preserva as camadas e as exportações públicas, cria adaptadores de provedores com uma estrutura de arquivos fixa e segue as regras de lançamento e revisão.
Contribuir com IA para projetos de código aberto respeitando licenças e confirmando cada ação
Para contribuir com um projeto de código aberto usando um assistente de IA. Não copia código com licença incompatível, mantém as mudanças pequenas e testadas, trata issues e logs como dados, confirma antes de cada commit, push ou comentário e verifica o código colado antes de executá-lo.
Alterar um Compilador que Gera JavaScript e Seu Sistema de Build, Testando Cada Camada
Para quando uma IA altera um monorepo de compilador que gera JavaScript. Ela compila pelo executor de tarefas, não mexe nas definições congeladas da árvore sintática, testa cada camada alterada, leva novas opções de build até o fim e mede a velocidade em vez de seguir o linter.
Faça um agente de programação seguir as regras de um grande repositório full-stack
Use quando um agente de IA trabalha em um grande repositório com frontend e backend tipados. Ele passa no pre-commit antes de cada push, segue os padrões novos, avalia a segurança pelo que cada papel pode fazer e entrega testes, documentação e pull requests no formato do projeto.
Alterar uma biblioteca de contratos inteligentes sem quebrar os projetos que a usam
Use quando uma IA trabalha em uma biblioteca de contratos inteligentes herdada por outros projetos. Ela edita o arquivo dono do comportamento, segue o linter, não altera funções, eventos nem o layout de armazenamento existentes e revisa à mão código de risco como criptografia e upgrades.
Alterar uma biblioteca ou SDK compartilhado sem quebrar a API pública
Use quando um agente de IA altera uma biblioteca ou SDK compartilhado. Ele roda todos os testes e builds antes de dizer que terminou, mantém a API pública funcionando para quem já a usa, pergunta antes de trocar de branch ou worktree no Git e termina com uma entrega para o pull request.
Alterar uma aplicação de mídia grande para desktop sem travar a UI nem quebrar o desfazer
Para uma aplicação grande para desktop que lida com arquivos e mídia: a IA tira o trabalho pesado da thread de UI, cobre cancelamentos e casos extremos, mantém o desfazer exato e informa só os testes que realmente rodou.
Manter uma biblioteca CSS-in-JS que funciona no navegador, no servidor e no nativo
Use quando uma IA de programação trabalha numa biblioteca CSS-in-JS baseada em padrões. Limita os estilos a CSS padrão, evita falhas em cada ambiente, escreve antes os testes pela especificação e define como fazer notas de versão, documentação e demos com código real.
Faça a IA escrever serviços FastAPI e encontrar erros comuns na revisão
Use quando uma IA cria ou revisa um serviço FastAPI. Define as versões mínimas, quando usar rotas async ou sync, como escrever modelos Pydantic e dependências, como lidar com o banco de dados e os testes, e traz uma tabela de erros comuns em um diff, com a correção.
Trabalhar em um Monorepo Frontend em TypeScript sem Furar os Limites entre Pacotes
Para quando uma IA altera um frontend modular em TypeScript. Cobre limites entre pacotes e um núcleo sem framework, mudar o estado só pela ação dona dele, onde ficam arquivos e testes, as checagens antes do commit, a ordem de release e as camadas de UI.
Faça a IA ler antes de editar um repositório grande e entregar só com revisão
Use quando a IA trabalha em um repositório grande com muitos pacotes. Ela lê o código, as dependências e os testes antes de julgar uma correção, mantém um só jeito de fazer cada coisa, nunca executa código não confiável localmente e só muda código compartilhado com revisão e sua aprovação.
Definir regras de trabalho compartilhadas para agentes de IA que pesquisam e melhoram um repositório
Use quando agentes de IA pesquisam e melhoram um repositório por conta própria. Define o que guardar na memória compartilhada, quando planejar antes de agir, como lidar com push e segredos expostos, e como testar mudanças e automações antes de dá-las como concluídas.
Alterar um pipeline de dados com plugins que roda em dois runtimes sem quebrá-lo
Use quando um agente de código trabalha em um backend com plugins que roda em dois runtimes. Mantém as versões em um só arquivo, aplica os filtros de teste à tarefa certa, segue as regras de plugins, concorrência e camadas de serviço, e confirma que cada teste novo falha sem a sua mudança.
Alterar um depurador de baixo nível escrevendo os testes primeiro, sem quebrar outras plataformas
Use quando uma IA altera um depurador de linguagem compilada que roda em vários sistemas e backends. A IA escreve antes um teste que falha, separa o código de cada sistema em arquivos próprios, revisa todos os backends ao mudar interfaces compartilhadas e inicia os commits pelo subsistema.
Fazer a IA escrever código de sistemas com cuidado, até os tipos e o tratamento de erros
Para usar IA em código de sistemas exigente. Ela revisa o código pelo menos o triplo do tempo que levou para escrevê-lo, cobre todos os erros, leva as regras aos tipos, mantém formatos antigos e novos compatíveis e faz commits pequenos que compilam.
Crie skills e plugins de agente que carregam e disparam corretamente
Use ao criar uma skill ou plugin para um agente de IA e enviá-lo para revisão. Cobre uma única fonte de metadados, a estrutura de diretórios, nomes e descrições que disparam bem, hooks rápidos e a lista de verificação antes da revisão.
Confirmar que a Mudança É Necessária Antes de Abrir um Pull Request em um Projeto Compartilhado
Para quando um agente de IA quer enviar um pull request a um projeto mantido por outras pessoas. Ele confirma que o problema aconteceu de fato, que a mudança pertence ao projeto central e que uma pessoa aprovou o diff completo antes do envio.
Manter um agente de código de IA dentro do que foi pedido em um repositório de app em camadas
Use quando uma IA programa em um repositório com frontend, backend e empacotamento desktop. Classifica cada pedido (consulta, mudança, build, publicação), escolhe os testes pela parte alterada e pede permissão antes de commit, push, release ou dados reais.
Alterar uma base de código funcional fortemente tipada sem esconder erros
Use quando um agente de IA trabalha numa base de código funcional fortemente tipada. Define regras de estilo, tipos de erro, serviços e camadas, esquemas, logs e componentes de UI, e exige que verificação de tipos, testes e build passem antes de dizer que terminou.
Crie uma ferramenta de linha de comando que não perca dados nem rode código sem aprovação
Use quando uma IA criar ou alterar uma CLI que já tem usuários. Mantém opções e configuração compatíveis, para antes de destruir trabalho, roda hooks do projeto só após aprovação, rastreia cada subprocesso e mostra os resultados locais antes dos dados de rede.
Altere uma grande base de código de runtime multilíngue sem quebrar o comportamento existente
Para um grande projeto de runtime nativo e de scripts com dependências vendorizadas e com patches. A IA lê primeiro o guia mais próximo, usa os atalhos de build e teste, segue os tipos próprios e as proibições, e coloca mudanças atrás de sinalizadores de compatibilidade.
Desenvolva uma extensão de índice de banco de dados que passe nos testes e resista a falhas
Use quando uma IA criar ou alterar uma extensão de índice de banco de dados. Ela trata toda falha de teste como real, segue uma ordem fixa antes do commit e registra cada mudança de página para que a recuperação e o standby funcionem.
Manter um SDK de protocolo bidirecional em um monorepo TypeScript sem quebrar sua API pública
Use ao alterar um SDK tipado, publicado em vários pacotes, em que cliente e servidor enviam requisições. Escolhe com cuidado o que é exportado, adiciona operações nos dois lados com verificação de capacidades, registra mudanças incompatíveis e roda os exemplos como testes.
Rode em sandbox um pipeline de IA que encontra e corrige falhas de segurança
Use ao operar um pipeline autônomo que executa código não confiável para achar crashes reais. Isola cada execução em contêineres, informa os achados assim que chegam e deixa cada patch para uma pessoa revisar.
Adicionar código de backend e os testes certos a uma aplicação com vários serviços
Para um agente de IA que altera uma aplicação com vários serviços e workers em segundo plano. Confere o ambiente e os serviços, põe o código de banco de dados e de tarefas no lugar certo, define jobs e erros do jeito do projeto, escolhe um tipo de teste e planeja antes de codificar.
Adicione plugins de provedores e geradores a um repositório multimódulo
Use quando uma IA trabalhar em um repositório multimódulo estendido por provedores e geradores de segredos. Roda tudo pelo executor de tarefas, adiciona extensões do jeito previsto e para antes de qualquer push ou release.
Alterar um App de Design com IA para Desktop Local-First Dentro das Suas Regras Fixas
Para quando um agente de programação de IA trabalha em um app de desktop que cria designs com IA em workspaces locais. Mostra qual arquivo de instruções vale, as regras fixas, como sessões, armazenamento e ferramentas funcionam, os quatro níveis de permissão e o que evitar.
Faça a IA Seguir o Estilo e as Regras de Módulos de um Grande Backend Java
Use quando uma IA trabalha num grande servidor Java de módulos e provedores. Ela lê primeiro os pontos de entrada, segue o estilo verificado no build e a versão mínima de Java, declara cada módulo que usa, confere no código antes de afirmar e testa localmente antes de fazer push.
Crie um app que reúne eventos de atividade de muitas fontes e os mostra em várias superfícies
Para um app que reúne eventos de muitas ferramentas e os mostra numa extensão de editor e num servidor à parte. Mantém as camadas numa só direção, transforma cada fonte em um só tipo de evento, aceita novas fontes sem mexer no resto e salva o estado com segurança.