[🤖] Saber usar a IA ativamente faz as possibilidades parecerem infinitas

✨ Resumo do GPT-5.6 Sol 　

Um registro de como conectei NAS, roteador e HTTPS, corrigi até a interface quebrada de um celular real ligado por USB e senti o quanto se amplia a área que consigo manejar diretamente ao trabalhar com IA.

Vi as telas do NAS e do roteador junto com o Computer Use

As primeiras coisas em que esbarrei hoje foram o NAS e o roteador.

Para usar o serviço de fora, não bastava subir o Docker. O domínio precisava chegar até a internet da empresa, o roteador tinha que encaminhar a solicitação ao NAS, o NAS precisava apresentar o certificado e, depois, o Reverse Proxy tinha que enviá-la ao contêiner interno. Antes, eu teria começado procurando manuais enquanto alternava entre as telas administrativas do roteador e do NAS.

Desta vez, eu entrei nas telas administrativas e aprovei o escopo das mudanças, enquanto a IA olhava as telas reais pelo Computer Use e avançava comigo.

No alto do navegador apareceu um aviso de que a IA havia começado a depurá-lo diretamente. Entreguei a tela exatamente como eu a via e verificamos juntos o que estava normal e onde havia bloqueio.

Primeiro conferimos as configurações existentes, deixamos intactas as conexões do site e do e-mail que não podiam ser mexidas e adicionamos apenas o necessário para o novo serviço. Enviei ao NAS a imagem Docker criada no Mac, executei-a em um ambiente Compose separado e conectei o Reverse Proxy e o certificado HTTPS.

Aqui a divisão de papéis ficou ainda mais clara. Eu cuidei do login, da definição do objetivo, da decisão sobre quanto preservar do ambiente existente e da aprovação das mudanças reais. Dentro das telas que abri, a IA leu as configurações do roteador e do NAS e conectou camadas técnicas diferentes, do Docker e Reverse Proxy ao certificado.

A IA não alterou configurações externas por conta própria. Eu fiz o login e aprovei as mudanças importantes, e conferimos o resultado etapa por etapa, mantendo uma forma de restaurar o ambiente anterior. O envio real de SMS foi primeiro limitado a um único número interno aprovado, e confirmei o recebimento. Depois de terminar a conexão externa, também acessei o endereço HTTPS pela rede móvel do celular.

Escrevi separadamente sobre a migração das funções e dados existentes, a verificação de um SMS limitado e o caminho pelo qual uma solicitação externa chega ao serviço dentro do NAS em Migração da automação legada de férias para o NAS e conexão HTTPS externa.

Não dava para olhar diretamente a tela do celular?

Depois de chegar até aqui, perguntei à IA:

Você não consegue olhar a tela do meu celular e controlá-lo? Não existe uma ferramenta para isso?

Num mundo em que existe até virtualização do Android, parecia estranho a IA não conseguir ver um celular real conectado por USB. Descobri que o adb podia ler e controlar o estado do aparelho e que o scrcpy permitia exibir a tela real diretamente no Mac.

Depois de algumas trocas, a tela do meu celular apareceu de verdade no Mac.

Meu celular estava ali dentro da tela do Mac, mostrando até uma notificação de que o Codex estava trabalhando. A partir daquele momento, a IA deixou de parecer apenas uma janela que respondia perguntas. Parecia uma ferramenta capaz de olhar comigo para o dispositivo real que eu podia ver e tocar.

Corrigi a interface olhando para o celular real

O scrcpy não terminou como uma ferramenta que apenas exibia a tela do celular.

Com um aparelho real e a depuração USB ativada conectado ao Mac, a IA podia usar adb para capturar a tela, ler a estrutura da interface, tocar, rolar e digitar. Pelo scrcpy, eu acompanhava o processo inteiro em tempo real. Não era escolher um ou outro: a tela era vista com scrcpy, enquanto o adb cuidava das operações repetidas e da coleta de evidências.

No monitor, a IA lia a tela e organizava a próxima ação. Logo à frente, o mesmo serviço estava aberto no celular real.

Abri no Chrome do celular o serviço que eu estava criando, entrei e percorri os menus. Foi então que saltaram os problemas que eu não havia percebido ao apenas imitar uma janela pequena do navegador do PC. No celular, a barra lateral ocupava quase toda a tela, e cartões e textos ficavam esmagados na vertical. O título e os botões da lista de funcionários quebravam letra por letra, e nem dava para entender os filtros do histórico de SMS e da gestão de férias.

Uma imagem foi mais forte do que explicar que havia um problema. As letras de Lista de funcionários caíam uma por uma, e nos filtros restavam apenas ícones e pedaços de texto. Defeitos que eu deixara passar ao estreitar uma janela no PC não conseguiam se esconder numa tela real do tamanho da palma da mão.

Em todas as comparações abaixo, a esquerda mostra antes da correção e a direita, depois.

Também não parei depois de corrigir o código. Fiz novo deploy da tela alterada, entrei outra vez no mesmo celular, abri os menus, rolei e conferi. A lista de funcionários passou a ser legível na horizontal, e tabelas largas puderam rolar o necessário em vez de serem comprimidas à força.

Olhando para a tela, dei os critérios: “Isto não dá para ler” e “Não esmague a tabela; deixe que eu me mova para vê-la”. A IA conectou esses critérios a mudanças reais no layout e no código. Depois do deploy, julgar se estava mesmo corrigido voltou para os meus olhos.

Nas telas com muitos filtros, o problema era ainda mais evidente. A causa era tentar enfiar todos os campos em uma única linha na largura estreita do celular. Reorganizei as telas de histórico de SMS e gestão de férias em torno de duas colunas e movi o intervalo de datas para uma linha própria.

Essas telas de antes e depois não são cópias de dados operacionais. Depois de encontrar o problema no celular real, renderizei novamente o código antigo e o corrigido, com os mesmos dados sintéticos e o mesmo tamanho móvel. O incômodo visto com meus olhos levou a uma alteração no código e retornou à verificação no aparelho real.

Parecia uma janela, mas não era um aplicativo

Já era fascinante corrigir as coisas olhando para a tela do celular real, mas o que veio depois foi ainda mais engraçado.

Eu queria que a janela do scrcpy aparecesse e desaparecesse ao pressionar fn+s no BetterTouchTool. Todos os outros aplicativos funcionavam bem, mas, por algum motivo, apenas o scrcpy não. Capturei a tela de configuração e mostrei à IA.

A causa era simples.

O que eu havia selecionado no BetterTouchTool não era um pacote comum de aplicativo macOS, mas o executável do scrcpy instalado pelo Homebrew. Ele abre uma janela parecida com um aplicativo, mas não é o tipo de .app comum esperado pelo Show / Hide Specific Application do BetterTouchTool. Por isso o método que funcionava com outros aplicativos não funcionava direito com o scrcpy.

Não era um problema do celular. O atalho em si também não era o problema. Aos meus olhos era uma janela como qualquer outra, mas a questão estava em como o Mac reconhecia aquela janela como processo e aplicativo.

Para mim, era uma janela igual às de outros aplicativos. A IA conectou a configuração do BetterTouchTool que mostrei ao caminho real do executável e descobriu por que só aquela janela não se comportava como um aplicativo comum.

No fim, em vez de uma ação para mostrar ou ocultar um aplicativo normal, mudei para um script de shell que encontrava diretamente o processo scrcpy e controlava tanto sua execução quanto a visibilidade da janela. O mesmo fn+s agora funcionava como eu queria.

No instante em que ouvi a explicação, simplesmente ri.

Uau… dá para fazer até isto?

Já não preciso conhecer todas as tecnologias de antemão

Antes, haveria coisas demais para pesquisar a partir daqui.

Docker e NAS, roteador, DNS, certificados, Reverse Proxy, depuração do Android, adb e scrcpy, até a forma como o macOS distingue janelas de aplicativos. Se eu pesquisasse uma por uma, elas se espalhariam como problemas de áreas completamente diferentes.

Talvez cada tecnologia isolada nem seja tão difícil. Mas não são áreas que costumo conhecer profundamente. Quando nem sei o que procurar, um problema pequeno pode facilmente virar horas de trabalho.

Com a IA no processo, o fluxo mudou.

Eu disse o resultado que queria. Mostrei a tela real. Mostrei de novo o ponto que falhava. A IA conectou Docker, NAS, roteador, DNS e HTTPS, além do celular, adb, scrcpy, janelas do macOS e configurações do BetterTouchTool, num único fluxo.

De um lado, ela via o NAS e o navegador; em outra sessão, investigava o caminho entre Android e SMS; em outra janela, eu revisava o resultado. Mesmo com as telas divididas, meu papel continuava igual: definir o objetivo, aprovar até onde mudar e julgar se o resultado estava correto.

Eu não teria sentido isso se a IA apenas tivesse me contado muitos conhecimentos. Esse conhecimento virou comandos de terminal, toques no celular e configurações em telas administrativas e, no fim, voltou como mudança na tela que eu realmente uso. Não foi resposta. Foi execução.

Eu não havia estudado todas essas camadas de antemão. Também não fiquei sem fazer nada e simplesmente disse “resolva sozinho”. Continuei olhando os resultados, apontando o que parecia estranho e fazendo a pergunta seguinte.

Antes escrevi que alfabetização em IA é, no fim, a capacidade de instruir. Hoje essas palavras pareceram um pouco mais reais.

Dar instruções não era escrever uma linha de prompt impressionante. Era explicar o estado que eu queria, entregar a tela diante de mim e corrigir quando o resultado fosse diferente. Se eu soubesse repetir isso, poderia entrar muito mais fundo do que imaginava até em áreas que antes desconhecia.

A IA amplia o alcance das minhas mãos e dos meus olhos

Usar IA não fez de mim, de repente, especialista em todas as tecnologias.

Na verdade, ao trabalhar diretamente, continuam surgindo momentos em que a IA faz um julgamento estranho ou vai longe demais numa direção que eu não queria. Se eu não souber o que quero ou não tiver critérios para avaliar o resultado, por mais que a IA trabalhe, será difícil chegar a um resultado correto.

Mas o contrário também é verdadeiro.

Se eu definir o objetivo, mostrar o estado real, detectar a direção errada e continuar movendo a IA, a história muda completamente. Coisas que antes eu deixaria passar dizendo “não conheço essa área” tornam-se coisas que posso tocar diretamente. Não termina em instalar um programa: posso conectar um aparelho real, ver a tela, confirmar o funcionamento, colocar no servidor e mudar as partes incômodas do meu jeito.

Por isso, agora, em vez de pedir apenas que explique o resultado, quando a tela importa eu digo simplesmente: “Confira você mesmo. Com Computer Use.”

Em A mudança de paradigma do desenvolvimento gravada nos ossos e na carne, escrevi que o centro do trabalho do desenvolvedor está saindo da capacidade de digitar código e indo para planejamento, design, execução e feedback. O que fiz hoje seguiu exatamente esse fluxo.

Antes de quanto código eu havia memorizado, vinha o que eu realmente queria construir. Depois, vieram mostrar o contexto à IA, conectar as ferramentas e continuar corrigindo enquanto observava o resultado.

Hoje eu realmente senti isso.

Se eu souber usar ativamente a IA, consigo fazer muito mais coisas do que imaginava. Não é apenas receber respostas mais rápido. Amplia-se o alcance do que posso ver, tocar e corrigir diretamente.

Dizer que as possibilidades são realmente infinitas não pareceu exagero.