Codex amplia fortemente a coletânea de casos de uso

• A OpenAI reformulou amplamente a página de casos de uso do Codex, expandindo a divulgação de 12 para 52 casos de uso
• Agora, deixando de ser apenas um assistente de programação, ele passa a se posicionar como uma plataforma para delegar tarefas por equipes de toda a empresa, incluindo engenharia, design, dados, finanças, operações, QA e vendas
• De uso do computador (automação no Mac), gerenciamento da caixa de entrada do Gmail, Slack, Zoom, documentos, planilhas, modelagem financeira (DCF, fluxo de caixa, orçamento), desenvolvimento nativo para iOS/macOS, fluxos de trabalho para vendas e marketing, QA, automação, deploy, Evals e até o app do ChatGPT, a organização mostra como delegar fluxos de trabalho reais ao Codex

1. Configurar o Codex como um colega de trabalho (Automation / Integrations)

Dificuldade: Easy | Tempo necessário: Long-running

• Conecta ferramentas por onde o trabalho realmente flui, como Slack, Gmail, Calendar, Notion, GitHub, Linear e notas locais, em uma única thread do Codex para usá-lo como “um colega que conhece o contexto do meu trabalho”
• Na primeira execução, faz o Codex encontrar solicitações importantes que podem passar despercebidas, documentos alterados, decisões esquecidas e handoffs travados, enquanto o usuário dá feedback sobre o que é útil e o que é ruído
• Depois, é possível aplicar automações na mesma thread para que ele verifique o contexto periodicamente. Decisões que exigem julgamento são projetadas para serem encaminhadas ao usuário, sem que o Codex as trate por conta própria
• Indicado para: pessoas, operadores, gerentes, PMs e engenheiros que precisam acompanhar continuamente contextos de trabalho espalhados por várias ferramentas

2. Transformar feedback em ação (Data / Integrations)

Dificuldade: Easy | Tempo necessário: 30m

• Reúne feedback de várias fontes, como canais do Slack, issues do GitHub/Linear, CSVs de pesquisa, notas de entrevistas com clientes e documentos no Google Drive, organizando tudo em entregáveis revisáveis em Google Sheets ou Google Docs
• O Codex agrupa o feedback por tema, links de evidência, perguntas de acompanhamento e ações atribuídas, e pode transformar o conteúdo revisado em atualizações no Slack ou rascunhos de issues
• Se as fontes de feedback mudam continuamente, é possível aplicar automações na mesma thread para avisar apenas sobre novos temas ou itens cuja evidência ficou mais forte
• Indicado para: equipes que precisam transformar feedback beta, VOC de clientes, threads de issues e notas de pesquisa em ações de produto

3. Limpar e preparar dados bagunçados (Data / Knowledge Work)

Dificuldade: Easy | Tempo necessário: 5m

• Quando um CSV ou planilha mistura formatos de data, strings de moeda, linhas duplicadas, valores vazios, linhas de resumo e aliases, ele cria uma cópia organizada preservando o original
• O usuário define com clareza os problemas já visíveis e o formato de saída desejado, como um CSV limpo, um arquivo para upload ou uma nova aba na planilha
• O Codex também deixa o arquivo limpo junto com anotações sobre a qualidade dos dados, para que uma pessoa possa revisar antes da análise ou do upload
• Indicado para: equipes que precisam refinar arquivos de dados recebidos de vários sistemas para análise ou entrada em sistemas operacionais

4. Consultar dados tabulares (Data / Knowledge Work)

Dificuldade: Easy | Tempo necessário: 30m

• Ao fazer perguntas sobre CSVs, planilhas, exports de dashboards, Google Sheets ou arquivos de dados locais, o Codex inspeciona as colunas e executa cálculos, agregações e geração de gráficos
• Em vez de parar em uma resposta simples, o fluxo recomendado é criar visualizações em HTML para navegador que podem ser abertas diretamente no app do Codex
• Após a primeira análise, é possível continuar análises subsequentes na mesma thread, comparando por região, coorte, produto, semana, versão de modelo ou segmento de clientes
• Indicado para: trabalhos orientados por dados que exigem cálculos rápidos, gráficos simples e resumos para reuniões

5. Revisar Pull Requests no GitHub (Integrations / Workflow)

Dificuldade: Easy | Tempo necessário: 5s

• É possível conectar o code review do Codex a uma organização ou repositório no GitHub para receber revisões automáticas a cada PR, ou solicitar revisão manual pelos comentários do PR
• O foco principal é obter sinais adicionais de revisão que pessoas podem deixar passar, como regressões de segurança, testes ausentes, mudanças de comportamento arriscadas e falta de documentação
• Ao registrar prioridades de revisão e regras por arquivo em AGENTS.md, é possível personalizar os critérios de revisão do Codex de acordo com o repositório
• Indicado para: equipes que precisam de sinais extras de revisão antes do merge e grandes codebases em produção

6. Gerenciar sua caixa de entrada (Automation / Integrations)

Dificuldade: Easy | Tempo necessário: 5m

• Ao conectar o Gmail, ele encontra e-mails que precisam de resposta e redige rascunhos no tom do usuário com base em e-mails enviados recentemente ou exemplos de escrita já aprovados
• Quando falta contexto apenas com o e-mail, é possível fazê-lo buscar decisões recentes, responsáveis, arquivos e bloqueios em ferramentas de trabalho como Slack, Google Drive e notas de projeto
• A primeira execução deve ser tratada como calibração: após dar feedback sobre quais e-mails ignorar e qual tom usar, isso pode evoluir para uma automação periódica
• Indicado para: pessoas que querem lidar de forma repetitiva com triagem da caixa de entrada e criação de rascunhos de resposta

7. Implementar design de front-end responsivo (Front-end / Design)

Dificuldade: Intermediate | Tempo necessário: 1h

• Recebe screenshots, briefs de design e imagens de referência e os transforma em uma UI responsiva que reutiliza o design system, tokens e componentes do repositório existente
• O Codex abre um navegador real com Playwright e itera sobre a implementação comparando o resultado com a referência em breakpoints de desktop e mobile
• Em pontos ambíguos, é melhor instruí-lo a escolher a implementação mais simples alinhada aos padrões existentes, em vez de criar um novo design system, e explicitar as hipóteses adotadas
• Indicado para: implementação de novas telas de front-end e trabalho de acoplar telas desenhadas a um app existente

8. Entender uma grande base de código (Engineering / Analysis)

Dificuldade: Easy | Tempo necessário: 5m

• Ao entrar em um repositório ou área funcional desconhecida, você pode pedir ao Codex que explique o fluxo de requisições, responsabilidades dos módulos, onde ocorre a validação de dados, efeitos colaterais e quais arquivos ler em seguida
• Em vez de um resumo geral, explicações mais práticas surgem quando se especifica uma área concreta do sistema
• Recomenda-se um fluxo de perguntas de acompanhamento para confirmar onde está a lógica de negócio, os pontos de validação, tarefas em segundo plano que costumam passar despercebidas e os testes a executar após alterações
• Indicado para: onboarding de novos engenheiros e desenvolvedores que precisam entender rapidamente o fluxo do código antes de alterar uma funcionalidade

9. Criar a estrutura base de um app para Mac (macOS / Code)

Dificuldade: Advanced | Tempo necessário: 1h

• Usa o plugin Build macOS Apps para criar a estrutura de um app nativo de Mac em SwiftUI, definindo uma arquitetura com barra lateral, painel de detalhes e inspetor baseada em NavigationSplitView
• A orientação é projetar desde o início uma estrutura natural para apps desktop, incluindo menus, barra de ferramentas, atalhos de teclado e Settings scene
• O objetivo é uma estrutura de app para Mac em que janelas, estado de seleção, comandos e configurações funcionem com estabilidade, e não apenas uma versão ampliada de um app de iPad ou web
• Indicado para: apps para Mac com necessidade de barra lateral e inspetor, como editores, bibliotecas, ferramentas administrativas e ferramentas de revisão

10. Operar meu computador com o Codex (Knowledge Work / Workflow)

Dificuldade: Easy | Tempo necessário: 5m

• Com o Computer Use, o Codex pode ver, clicar e digitar diretamente em apps no Mac, executando tarefas que atravessam vários apps e janelas
• É adequado para fluxos dentro da UI de apps comuns sem plugin dedicado, por exemplo buscar informações no Notes e inseri-las em outro sistema, ou verificar mensagens no Messages e redigir respostas
• É recomendável começar o pedido com @Computer e incluir tanto o resultado desejado quanto as ações perigosas que devem ser interrompidas
• Indicado para: tarefas repetitivas que só podem ser feitas dentro da UI do app, trabalho intelectual que envolve várias janelas e arquivos

11. Automatizar a triagem de bugs (Automation / Quality)

Dificuldade: Intermediate | Tempo estimado: 1h

• Faça o Codex percorrer os lugares onde sinais de bug se acumulam, como alertas do Sentry, threads do Slack, issues no Linear/GitHub, checks com falha em PRs, logs e tickets de suporte
• Primeiro, monte uma lista de candidatos com uma varredura manual, ajuste no mesmo thread quais itens são úteis e depois migre para uma automação regular
• Quando houver confiança suficiente, é possível fazer o Codex redigir até issues no Linear, atualizações no Slack, comentários no GitHub e rascunhos de notas de handoff
• Indicado para: equipes de produto/engenharia que precisam priorizar diariamente relatórios de bugs espalhados por várias ferramentas

12. Gerar decks de slides (Data / Integrations)

Dificuldade: Easy | Tempo estimado: 30m

• O Codex edita arquivos PowerPoint diretamente por código e combina isso com geração de imagens para atualizar um deck existente ou criar um novo
• Especifique regras pré-entrega como posição do logo, disposição de texto/imagens em slides específicos, preservação da identidade visual existente e verificação de overflow e substituição de fontes
• Recomenda-se manter os slides como .pptx editável, com o Codex aplicando regras de layout repetíveis slide por slide
• Indicado para: equipes que transformam entradas estruturadas ou anotações em materiais de apresentação, e trabalhos que exigem modificar decks existentes em larga escala

13. Iniciar tarefas de programação pelo Slack (Integrations / Workflow)

Dificuldade: Easy | Tempo estimado: 5m

• Instale o app do Slack, conecte o repositório e o ambiente, depois mencione @Codex no thread para iniciar uma tarefa de código
• Se o thread contiver contexto suficiente sobre pedido, restrições e resultado desejado, o Codex executará uma tarefa na nuvem com base nesse contexto
• Você pode abrir o link do resultado para revisar, e continuar ajustes adicionais no mesmo thread do Slack, se necessário
• Indicado para: equipes que querem encaminhar diretamente de discussões no Slack tarefas como triagem de issues, correções de bugs e pequenas implementações

14. Iterar rapidamente pequenas mudanças de UI (Front-end / Design)

Dificuldade: Easy | Tempo estimado: 5m

• Quando a estrutura do app já está definida, processe rapidamente pequenas mudanças de UI uma a uma, como spacing, alignment, color, copy, responsive behavior e state
• Recomenda-se um loop do tipo “uma observação visual por vez, uma pequena edição por vez, uma verificação no navegador por vez” usando um modelo rápido como o Codex-Spark
• Defina com precisão o escopo da mudança e peça para preservar componentes existentes, tokens, layout primitives e fluxo de dados
• Indicado para: ajustes finos de UI surgidos em revisão de design e mudanças que precisam ser aplicadas na hora durante uma revisão de produto

15. Coordenar o onboarding de novos contratados (Integrations / Data)

Dificuldade: Intermediate | Tempo estimado: 30m

• Reúna a lista aprovada de novos contratados, o tracker de onboarding, mapeamentos de gerente/equipe, estado de preparação de equipamentos e contas e marcos de calendário para criar um pacote de onboarding revisável
• Recomenda-se que a primeira passagem seja somente leitura, e que convites reais, DMs, e-mails, criação de canais e atualizações em sistemas sejam aprovados explicitamente após revisão
• Também é possível preparar resumos por equipe, lacunas de prontidão, nomes de espaços de boas-vindas, lista de convites, checklist da primeira semana e rascunhos de comunicados
• Indicado para: People, Recruiting, IT, Workplace Operations e gerentes que vão receber novos contratados

16. Aprender um novo conceito (Knowledge Work / Data)

Dificuldade: Intermediate | Tempo estimado: 30m

• Faça o Codex ler materiais densos como artigos, materiais de aula e documentos longos, e organizar problema central, contribuições, métodos, experimentos, limitações e conceitos prévios
• É possível usar Subagents para dividir papéis como compreender a estrutura do texto principal, pesquisar conhecimento prévio, analisar figuras/fórmulas e redigir o relatório final
• O ideal é que o resultado fique em um formato revisável depois, como relatório em Markdown, diagrama Mermaid, concept map ou tabela de claim-to-evidence
• Indicado para: pessoas que precisam aprender rapidamente uma área de pesquisa desconhecida, conceitos técnicos complexos ou materiais extensos de curso

17. Atualizar integrações de API (Evaluation / Engineering)

Dificuldade: Intermediate | Tempo estimado: 1h

• Migre integrações existentes com a OpenAI API para os modelos e recursos de API mais recentes e recomendados, preservando o comportamento e validando regressões ao mesmo tempo
• Em vez de apenas trocar o nome do modelo, primeiro faça um inventário dos endpoints atuais, premissas de tool, formato de resposta, prompts e caminhos de avaliação
• Recomenda-se usar openai-docs para verificar os guias mais recentes de modelos/prompts e validar o comportamento antes e depois da mudança com um pipeline de avaliação como o Promptfoo
• Indicado para: produtos que usam modelos/endpoints legados e equipes que precisam de testes de regressão para upgrades de modelo

18. Implantar um app ou site (Front-end / Integrations)

Dificuldade: Intermediate | Tempo estimado: 30m

• Com base em repositório, capturas de tela, briefing de design, ideia de produto, documentação de API e fontes de dados, o Codex cria ou modifica um app web e faz a implantação até uma preview URL do Vercel
• O ponto-chave é fazer verificações do projeto antes da implantação, build/testes, análise de logs de falha e validação da preview
• Mesmo após a implantação, é possível continuar no mesmo thread com ajustes de layout mobile, atualização com dados mais recentes e correções em build logs com falha
• Indicado para: equipes que querem transformar rapidamente uma ideia ou design em uma preview web compartilhável

19. Converter designs do Figma em código (Front-end / Design)

Dificuldade: Intermediate | Tempo estimado: 1h

• Por meio do servidor MCP do Figma, obtenha o contexto de design, variáveis, assets e variants de nós exatos e depois traduza isso em código de acordo com o design system do repositório existente
• Recomenda-se começar a implementação garantindo estrutura e referências na ordem get_design_context e, se necessário, get_metadata, get_screenshot
• Com o Playwright, compare no navegador o resultado implementado com a referência do Figma e faça correções iterativas em diferenças de comportamento responsivo e interações
• Indicado para: equipes de design/front-end que precisam implementar no codebase existente telas ou fluxos já finalizados no Figma

20. Fazer QA do seu app com Computer Use (Automation / Quality)

Dificuldade: Intermediate | Tempo estimado: 30m

• O Computer Use vê a interface real, clica, digita e rola a tela para executar os principais fluxos do usuário e registrar os pontos de falha
• Instrua com clareza o ambiente, os fluxos principais a serem testados, o formato do relatório de bugs, os critérios de severidade, os passos de reprodução e os resultados esperados/reais
• Ele consegue capturar tanto bugs funcionais quanto problemas de UI, e organiza os resultados no formato de um resumo de triagem para relatórios de QA ou para encaminhamento a engenheiros
• Indicado para: validação de fluxos principais antes do release, equipes que querem estruturar o QA manual

21. Analisar datasets e gerar relatórios (Data / Analysis)

Dificuldade: Intermediate | Tempo estimado: 1h

• Importa arquivos de dados desorganizados e faz limpeza, junção, análise exploratória, visualização e modelagem, empacotando tudo em relatórios ou dashboards usados na tomada de decisão
• É importante fazer com que o Codex entenda primeiro o ambiente Python do projeto, o gerenciador de pacotes, a pasta de saída e as convenções de scripts
• Tarefas repetitivas como organizar notebooks, exportar spreadsheets e empacotar o relatório final podem ser transformadas em uma skill reutilizável para reaproveitar o mesmo fluxo de análise com facilidade
• Indicado para: analistas/equipes de produto que precisam de entregáveis analíticos reproduzíveis, da limpeza de dados até gráficos, notas e relatórios

22. Concluir tarefas a partir de mensagens (Knowledge Work / Integrations)

Dificuldade: Easy | Tempo estimado: 5m

• O Computer Use encontra e executa tarefas ocultas em threads do Messages, como agendamentos, pesquisas, coordenação de horários, envio de recibos e consolidação de informações
• Você pode indicar remetentes ou threads específicos e, após concluir a tarefa, pedir que ele redija um rascunho de resposta para enviar na thread original
• É importante instruí-lo a sempre parar e pedir aprovação antes de ações difíceis de reverter, como pagamento, pedido ou confirmação de reserva
• Indicado para: pessoas que querem executar pequenas tarefas surgidas em mensagens pessoais sem deixar nada passar

23. Criar um PoC a partir de uma ideia (Front-end / Engineering)

Dificuldade: Intermediate | Tempo estimado: 1h

• Primeiro, cria-se um mockup de UI de alta qualidade com GPT Image/ImageGen para definir a direção visual e, com base nesse mock, implementa-se um protótipo funcional com Build Web Apps ou o plugin Game Studio
• É adequado para ideias iniciais de produto em que um PoC realmente clicável traz mais respostas do que um simples plano em documento
• No fim, é recomendável anexar as imagens que serão implementadas em um novo turn para que o Codex possa referenciá-las diretamente
• Indicado para: equipes que querem visualizar e validar rapidamente ideias de dashboard, ferramentas, apps web ou jogos

24. Criar jogos baseados em navegador (Engineering / Code)

Dificuldade: Intermediate | Tempo estimado: Long-running

• Em vez de sair codando direto a partir do briefing do jogo, peça primeiro a criação de um PLAN.md com objetivos do jogador, loop principal, controles, condições de vitória/derrota, renderização e plano de assets
• Use o ImageGen para criar concept art, sprites, fundos e assets de UI, e itere testando a sensação de controle e o estado da tela no navegador real com Playwright
• Como jogos exigem verificação contínua de código, UI, assets, balanceamento e deploy, este é um bom exemplo de trabalho iterativo de longo prazo para o Codex
• Indicado para: criação de jogos de navegador do zero ou trabalhos que precisam iterar e validar protótipos de jogabilidade e visual

25. Melhorar problemas difíceis por iteração (Engineering / Analysis)

Dificuldade: Advanced | Tempo estimado: Long-running

• Forneça um sistema de avaliação claro, scripts de pontuação e artefatos revisáveis para que o Codex rode um loop de melhoria baseado em score
• Use juntos verificações determinísticas e pontuações de LLM-as-a-judge, e defina uma stopping rule para o score geral e a média do judge
• A estrutura faz o Codex repetir, a cada iteração, a checagem da saída atual, a medição da pontuação, a aplicação de uma melhoria, a reavaliação e o registro em log
• Indicado para: problemas de otimização que não se resolvem de uma vez, trabalhos em que a qualidade visual/subjetiva precisa ser melhorada várias vezes

26. Salvar workflows como Skill (Engineering / Workflow)

Dificuldade: Easy | Tempo estimado: 5m

• Salva como skill reutilizável threads do Codex que funcionaram bem, regras de review, comandos de teste, checklists de release, regras de design, exemplos de escrita e scripts específicos de repositório
• Use $skill-creator para estruturar quando ela deve ser acionada, quais materiais e comandos devem ser usados e qual saída é necessária
• Skills no diretório home podem ser usadas em qualquer repo, e skills internas ao projeto podem ser commitadas e compartilhadas com a equipe
• Indicado para: equipes que querem fazer o Codex lembrar tarefas recorrentes em vez de colar prompts longos toda vez

27. Atualizar documentação (Engineering / Code)

Dificuldade: Easy | Tempo estimado: 30m

• Lê em conjunto mudanças de código, testes, release notes e o contexto de PRs/issues para atualizar README, documentação para desenvolvedores, migration notes e runbooks
• É recomendável fazer o Codex localizar primeiro, na documentação existente, os nomes de features, chaves de configuração, comandos e exemplos relacionados, alterando apenas a superfície mínima necessária
• Se for documentação pública, limite explicitamente para evitar misturar roadmap interno, informações de clientes ou contexto confidencial
• Indicado para: equipes de documentação técnica/engenharia que precisam manter a documentação alinhada às mudanças no comportamento do produto

28. Construir apps iOS (iOS / Code)

Dificuldade: Advanced | Tempo estimado: 1h

• O Codex pode fazer o scaffold de um app iOS em SwiftUI e montar um loop de build/execução CLI-first com xcodebuild ou baseado em Tuist
• Em projetos existentes, é possível orientá-lo a consultar scheme, simulator, screenshot e informações de automação de UI via XcodeBuildMCP enquanto trabalha
• Ao adicionar skills relacionadas a iOS, como SwiftUI expert, Liquid Glass e SwiftUI performance, é possível conduzir com mais estabilidade a implementação de UI, o uso de APIs mais recentes e a checagem de performance
• Indicado para: apps SwiftUI greenfield e projetos existentes de iPhone/iPad que exigem validação baseada em simulador

29. Refatorar sua codebase (Engineering / Code)

Dificuldade: Advanced | Tempo estimado: 1h

• Identifica código morto, lógica duplicada, módulos enormes, abstrações antigas e padrões legados, organizando tudo em unidades pequenas e revisáveis
• Como refatoração não é uma migração de stack, mas sim um trabalho de melhorar a forma do sistema preservando seu comportamento, é preciso deixar explícito que o comportamento público deve ser mantido
• Recomenda-se usar ExecPlan ou uma skill reutilizável para dividir grandes limpezas em checkpoints e repetir o fluxo de testes e validação
• Indicado para: equipes com codebases antigas em que adicionar funcionalidades está ficando cada vez mais caro e que precisam de reorganização com preservação de comportamento

30. Adicionar App Intents no iOS (iOS / Code)

Dificuldade: Advanced | Tempo estimado: 1h

• Identifica as ações e entidades centrais dentro do app para que possam ser usadas em superfícies do sistema como Shortcuts, Siri, Spotlight, widgets e controls
• Em vez da tela inteira, projeta primeiro algumas ações que o usuário gostaria de executar sem abrir o app e os objetos que o sistema precisa entender
• O fluxo faz com que o Codex analise o modelo, a navegação e os caminhos de acesso a dados do app existente para implementar de forma enxuta a primeira intent surface
• Ideal para: apps que já têm recursos úteis, mas não aparecem bem na automação e na busca do sistema iOS

31. Criar apps para macOS (macOS / Code)

Dificuldade: Advanced | Tempo: 1h

• Ao criar um app para macOS com base em SwiftUI, orienta a escolher primeiro o scene model, como WindowGroup, Window, Settings, MenuBarExtra e DocumentGroup
• Estrutura um loop de build/execução shell-first com xcodebuild, swift build e o script local do projeto script/build_and_run.sh
• À medida que o app cresce, aborda janelas, menus, barra lateral, Settings, interoperabilidade com AppKit e problemas de signing sob a ótica de apps desktop
• Ideal para: novos apps Mac que exigem estrutura nativa de desktop, ou melhorias de UI/build/distribuição em apps Mac existentes

32. Aplicar Liquid Glass (iOS / Code)

Dificuldade: Advanced | Tempo: 1h

• Com base no iOS 26 e no Xcode 26, compila um app SwiftUI existente e distingue entre o system glass obtido automaticamente em controles padrão e a UI customizada que precisa ser alterada manualmente
• Orienta a migrar a pilha customizada de blur/material para glassEffect, GlassEffectContainer, estilo de botão glass e transição com glassEffectID nativos
• Se for necessário oferecer suporte a versões anteriores do iOS, é preciso manter claramente #available(iOS 26, *) e um caminho de fallback
• Ideal para: equipes que querem migrar com segurança fluxos de alto tráfego de apps existentes para o Liquid Glass do iOS 26

33. Adicionar telemetria no Mac (macOS / Code)

Dificuldade: Advanced | Tempo: 30m

• Adiciona logs de alto sinal com base no Logger da Apple a fluxos como abertura de janela, seleção na barra lateral, comando de menu e marcos de sincronização em apps Mac
• Faz com que o Codex compile/execute o app e comprove, no Console ou em log stream, se os eventos reais ocorreram na ordem esperada
• A abordagem evita payloads sensíveis, define claramente subsystem/category e permite decidir o próximo patch com base em evidências em um loop de debugging agentic
• Ideal para: recursos de apps Mac cujo fluxo é difícil de rastrear só com code review, e loops de depuração baseados em logs

34. Depurar no simulador do iOS (iOS / Code)

Dificuldade: Advanced | Tempo: 1h

• O Codex e o XcodeBuildMCP encontram o scheme/simulador, compilam/executam o app e então leem a hierarquia de UI, realizando tap, type, swipe, screenshot e captura de logs
• Se necessário, conecta o LLDB para verificar stack frames, variáveis locais e breakpoints, transformando um bug report vago em uma correção pequena e reproduzível
• Após a alteração, o essencial é repetir o mesmo caminho no simulador e deixar evidências de que o bug desapareceu
• Ideal para: bugs de UI no iOS que só ocorrem em determinados fluxos de toque/rolagem/entrada, além de problemas de crash/hang/navegação

35. Auditar incidentes de dependências (Engineering / Quality)

Dificuldade: Advanced | Tempo: 1h

• Quando surge um advisory de pacote público ou um incidente na supply chain, orienta a não começar pelo patch e sim por um plano de auditoria conservador em modo somente leitura
• O Codex distingue fontes autoritativas de comentários gerais, define as evidências para comprovar ou descartar exposição e então inspeciona manifest, lock file, workflow de CI e scripts
• Como padrão, evita executar código não confiável, instalar, compilar ou testar até haver aprovação explícita
• Ideal para: equipes de segurança/engenharia e mantenedores que precisam responder rápido a incidentes de dependências

36. Preparar briefs de reunião (Integrations / Knowledge Work)

Dificuldade: Easy | Tempo: 30m

• Reúne, além do convite no Calendar, o contexto da reunião em documentos do Drive, threads do Slack, Gmail e notas anteriores para organizar objetivo, agenda, perguntas em aberto e um template de notas
• Faz com que o Codex monte primeiro um inventário de fontes e separe contexto confirmado, lacunas de fonte e perguntas em aberto
• O material de preparação da reunião deve ser curto, fácil de escanear e rastreável quanto à origem de cada informação
• Ideal para: gerentes, PMs, operadores, entrevistadores e pessoas que precisam organizar rapidamente o contexto antes de uma reunião

37. Executar playbooks de eventos (Integrations / Knowledge Work)

Dificuldade: Intermediate | Tempo: 1h

• Reúne canais de planejamento do evento, documentos/decks/planilhas/templates aprovados e prazos do calendário para criar um playbook sustentado por fontes
• O ponto central é gerenciar separadamente o texto público da página do evento e o checklist operacional interno, responsáveis, aprovações e perguntas em aberto
• Em eventos recorrentes, é possível automatizar a mesma thread para acompanhar prazos, aprovações, materiais ausentes e o status do checklist de lançamento
• Ideal para: gestão de programas de eventos em equipes de comunidade, DevRel, marketing e operações

38. Executar migrações de código (Engineering / Code)

Dificuldade: Advanced | Tempo: 1h

• Ao migrar de uma stack legada para a stack de destino, primeiro inventaria routing, modelo de dados, auth, config, background jobs, build, deploy, testes e contratos externos
• Seleciona uma estratégia incremental como compatibility layer, port módulo a módulo, branch-by-abstraction ou substituição no estilo strangler
• Em cada checkpoint, executa validação de paridade e trata explicitamente como exceção qualquer mudança visível exigida pela própria migração
• Ideal para: equipes que precisam conduzir trocas de framework/runtime/linguagem/sistema de build em unidades controladas

39. Refatorar telas em SwiftUI (iOS / Code)

Dificuldade: Advanced | Tempo: 1h

• Divide arquivos grandes de tela em SwiftUI em pequenas section views e em um fluxo de dados explícito, preservando comportamento e layout
• A skill de refatoração de views SwiftUI do plugin Build iOS Apps recomenda uma abordagem MV-first, evita adicionar view models desnecessários e move side effects para fora do body
• É importante acoplar um pequeno loop de verificação para confirmar que a UI não mudou e que o funcionamento também foi preservado
• Indicado para: telas SwiftUI em que layout, ramificações, trabalho assíncrono e ações inline se misturam no body

40. Criar rascunhos de PRD a partir de contexto interno (Integrations / Knowledge Work)

Dificuldade: Easy | Tempo necessário: 30m

• Reúne projeto no Linear, canal de planejamento no Slack, documentos no Notion/Google Drive, notas de reunião e materiais de pesquisa para redigir um PRD revisável
• É recomendável definir claramente um contrato de seções como problema, usuários, requisitos, UX, considerações técnicas, plano de lançamento, cronograma, decisões e open questions
• Primeiro, revise o apêndice de fontes para verificar que contexto o Codex usou e, em seguida, refine requisitos e open questions
• Indicado para: PMs/equipes de produto que transformam informações de discussões internas em PRD, proposal, launch brief ou decision memo

41. Prever fluxo de caixa (Data / Knowledge Work)

Dificuldade: Intermediate | Tempo necessário: 30m

• Insere caixa inicial, recebimentos esperados, folha de pagamento, pagamentos a fornecedores, dívida, impostos, capex, capital de giro e premissas de timing para criar uma planilha editável de previsão de fluxo de caixa
• Faz criar uma aba de resumo que preserve a cadência original e mostre premissas que causam violação do saldo de segurança e pressão de caixa
• Abre o .xlsx gerado no Codex para revisar fórmulas, cenários e premissas de timing, e faz ajustes na mesma thread
• Indicado para: equipes de finanças/operações que montam previsões de caixa de 13 semanas ou mensais

42. Criar um modelo de valuation DCF (Data / Knowledge Work)

Dificuldade: Intermediate | Tempo necessário: 30m

• Insere históricos financeiros, premissas de valuation e notas de modelagem para criar uma planilha DCF com crescimento de receita, margem, capex, capital de giro, WACC e valor terminal
• O Codex cria um .xlsx editável com abas do modelo, fórmulas, premissas e resumo de valuation, e o usuário revisa/edita diretamente no Codex
• Na mesma thread, é possível continuar verificando links de fórmulas, alterando premissas, adicionando cenários e refinando o modelo
• Indicado para: equipes de analistas/finanças que precisam criar e revisar rapidamente uma planilha de valuation

43. Revisar orçamento versus realizado (Data / Knowledge Work)

Dificuldade: Easy | Tempo necessário: 30m

• Insere plano orçamentário, exportação de realizado e notas de fechamento para mapear o realizado às categorias do plano e calcular variações em uma planilha de revisão
• Preserva os inputs originais, o mapeamento, as fórmulas de variação e a aba de resumo, separando problemas de reconciliação e open questions de finanças
• É possível continuar na mesma thread ajustando o mapeamento de categorias, adicionando recortes por departamento e redigindo um rascunho do resumo financeiro
• Indicado para: equipes de finanças que precisam explicar à liderança revisões de fechamento mensal e diferenças entre orçamento e gastos

44. Seguir objetivos (Engineering / Automation)

Dificuldade: Advanced | Tempo necessário: Long-running

• Usa /goal para que o Codex continue um trabalho de longa duração até uma condição de término verificável, sem parar em um único turno
• Especifica claramente o objetivo, a condição de parada, os arquivos/documentos/logs/planos que devem ser lidos primeiro e os comandos ou artefatos que comprovam o progresso
• Indicado para tarefas como migração, grande refatoração, loop de nova tentativa de deploy, experimento, jogo ou protótipo, em que o Codex pode avançar de forma autônoma por checkpoints
• Indicado para: trabalhos de programação que precisam continuar por horas, mas têm objetivo e loop de verificação claros

45. Adicionar Evals a aplicações de AI (Evaluation / Quality)

Dificuldade: Intermediate | Tempo necessário: 1h

• Analisa prompt, chamada de modelo, tool, retrieval, agent e requisitos de produto de um app de AI existente para adicionar uma suite de evals com Promptfoo
• Em vez de tentar avaliar o sistema inteiro de uma vez, começa por um comportamento visível ao usuário, como classification, extraction, summarization, routing, grounding, tool use ou regras de formato
• O Codex cria a configuração e os dados de teste, executa o eval localmente e deixa comandos que possam ser reutilizados depois
• Indicado para: equipes de apps de AI que querem criar testes de regressão antes de alterar modelo/prompt/retrieval/agent

46. Transformar user stories em mocks de UI (Integrations / Knowledge Work)

Dificuldade: Easy | Tempo necessário: 30m

• Reúne feedback espalhado em Slack, Linear, Google Drive, notas de chamadas com clientes etc., organiza tudo em user stories e restrições, e então gera direções de mock de UI com o ImageGen
• Se houver user stories claras, começa imediatamente; caso contrário, o Codex primeiro reúne o contexto para normalizar o problema e os requisitos
• O mock selecionado é anexado novamente em um novo turno para ser implementado como um protótipo funcional que reutiliza o sistema de design e os componentes do codebase existente
• Indicado para: equipes de produto/design/engenharia que precisam transformar feedbacks dispersos sobre o produto em uma direção visual e em mocks para revisão do time

47. Levar seu app para o ChatGPT (Integrations / Code)

Dificuldade: Advanced | Tempo necessário: 1h

• Projete o app do ChatGPT em torno de um único outcome de usuário bem específico e crie de ponta a ponta o servidor MCP, o componente web opcional e os metadados da ferramenta
• O Codex é uma boa opção para cuidar do design da surface da ferramenta e dos metadados, do scaffold do servidor MCP, da implementação do widget, da conexão com o ChatGPT e dos testes de golden prompt
• Na v1, defina primeiro se o widget é realmente necessário, se autenticação e deploy são necessários e se é possível validar testes locais com HTTPS e o developer mode
• Indicado para: equipes que estão criando seu primeiro app para ChatGPT ou querem começar sem inflar demais o servidor MCP/metadados de ferramenta

48. Criar apps React Native com Expo (Mobile / Engineering)

Nível: Intermediate | Tempo: 1h

• Use o plugin do Expo para fazer o scaffold do app React Native e siga o Expo Router, a convenção de pacotes nativos do Expo e o loop rápido de testes com Expo Go
• Migre para dev client ou EAS build apenas quando precisar de código nativo customizado, distribuição em lojas ou capabilities que o Expo Go não suporta
• O Codex ajuda a criar um workflow completo, incluindo navegação com feeling nativo e estados de loading/empty/error, e a validar pelo caminho mais rápido
• Indicado para: desenvolvedores que querem prototipar rapidamente ou preparar o lançamento de apps mobile com Expo antes de trabalhar em IDEs nativas

49. Criar uma CLI utilizável pelo Codex (Engineering / Code)

Nível: Intermediate | Tempo: 1h

• Encapsule em uma CLI composable as APIs, fontes de log, caixas de entrada de exportação, bancos de dados locais e scripts da equipe aos quais o Codex precisa acessar repetidamente, para que possa ser executada em qualquer repo
• Uma boa CLI oferece comportamentos agent-friendly, como paged search, leitura exata por ID, JSON previsível, download, índice local e draft-before-write
• Use $cli-creator para criar a CLI e $skill-creator para criar junto uma skill complementar que registra quando essa CLI deve ser usada
• Indicado para: equipes que precisam que o Codex leia, pesquise e manipule com segurança o mesmo serviço ou fonte de dados com frequência

50. Priorizar itens de ação no Slack (Automation / Integrations)

Nível: Easy | Tempo: 30m

• Leia DMs do Slack, DMs em grupo, menções em canais e respostas em threads para distinguir solicitações diretas, follow-ups implícitos, itens já resolvidos e ações que ainda estão ativas
• O Codex lê até o trecho final mais recente da thread, determina se ainda há pendências e então monta uma fila ranqueada de ações com base em urgência e impacto
• É possível criar rascunhos de resposta ou handoff, mas é recomendável limitar postagens/envios reais para que aconteçam só após revisão
• Indicado para: fluxos de trabalho de launch, support, product, operations e community em que as demandas chegam pelo Slack

51. Executar workflows operacionais verificáveis (Automation / Integrations)

Nível: Intermediate | Tempo: 30m

• Faça o Codex executar tarefas operacionais repetitivas, como atualização de acessos, lote de convites, mudança de quota, setup de cliente, checagem de roteamento e follow-up de migração
• Forneça com clareza a tabela de entrada, a fonte de aprovação, a política, o script/API/CLI/skill a executar, se haverá dry run e os limites de retry, sem deixar o Codex adivinhar campos ausentes
• Exija artifacts de verificação que uma pessoa possa conferir, como CSV de resultado, arquivo de log, link de dashboard, screenshot e checagem de PR
• Indicado para: operações que exigem entradas estruturadas e trilhas claras de aprovação/auditoria

52. Transformar reuniões em tarefas de follow-up (Automation / Integrations)

Nível: Intermediate | Tempo: 5m

• Use a transcrição do Zoom e o resumo do AI Companion para estruturar key takeaways, riscos, oportunidades, decisões e action items de reuniões com clientes
• O Codex cria rascunhos de follow-up email, plano de conta, atualização de CRM e notificação no Slack, mas o envio ou registro deve acontecer somente após revisão do usuário
• O efeito é maior quando Zoom cloud recording, transcript e AI Companion summary são conectados junto com ferramentas de destino como Gmail, Slack, Google Docs e CRM
• Indicado para: equipes customer-facing que precisam lidar com follow-ups repetitivos após calls de discovery, renewal, implementation e executive sponsor