Esse empregos estão ameaçados pela IA | Fernando Ulrich com Fabio Akita
Eficiência não é digitar mais rápido.
É transformar repetição em arquitetura.
Muito antes do “vibe coding”, já existia um tipo de programador que se recusava a repetir trabalho burro e transformava esforço manual em arquitetura.
Existe uma linhagem antiga na programação que nunca recebeu o devido respeito.
Muito antes de chamarem qualquer coisa de vibe coding, já existia o Programador Vagabundo.
Não o irresponsável.
Não o relaxado.
Não o sujeito que entrega porcaria e some.
O Programador Vagabundo de verdade é outra criatura.
É aquele que sente incômodo real diante de trabalho repetitivo.
Aquele que olha para um processo manual e enxerga uma falha de sistema.
Aquele que não aceita clicar cinquenta vezes, copiar e colar blocos iguais, repetir comandos idiotas ou corrigir pela décima vez um erro previsível que já deveria ter sido eliminado na origem.
Chamaram isso de preguiça.
Mas quase sempre era visão.
A preguiça certa
O Programador Vagabundo não quer fugir do esforço.
Ele quer fugir do desperdício.
Existe uma diferença brutal entre essas duas coisas.
Ele não evita trabalho importante.
Ele evita trabalho mecânico, burro, ritualístico, indigno de um cérebro humano minimamente funcional.
Se uma tarefa será repetida duas, três, dez vezes, ela já entrou no radar.
Se depende de atenção humana para não falhar, está mal desenhada.
Se um time inteiro executa um ritual operacional como se fosse tradição sagrada, provavelmente só falta alguém com coragem suficiente para exterminá-lo.
O Programador Vagabundo é esse alguém.
Eu nunca tive problema com trabalho difícil; meu problema sempre foi com trabalho burro.
Antes do hype, já existia a intenção
Hoje existe toda uma estética em torno de pedir, descrever, gerar, automatizar, orquestrar.
Tudo isso parece novo porque ganhou interface bonita, hype e nome vendável.
Mas a alma da coisa é antiga.
O Programador Vagabundo já vivia sob essa lógica muito antes:
não fazer na mão o que pode virar script,
não repetir no braço o que pode virar template,
não depender de memória humana onde pode existir contrato,
não confiar em disciplina onde pode existir sistema.
Em outras palavras: ele já praticava programação por intenção, mesmo quando ainda precisava montar essa intenção com shell script, alias, generator, macro, cron, lint, scaffold, pipeline, codegen, CI, CLI e toda sorte de gambiarra gloriosa que reduzisse a presença humana no trabalho idiota.
Antes de existir nome bonito para isso, eu já queria descrever intenção e deixar a máquina carregar o resto.
O erro de quem vê de fora
Quem olha de fora pensa que o Programador Vagabundo quer fazer menos.
Errado.
Ele quer fazer menos da parte errada.
Quer deslocar esforço da execução repetitiva para a modelagem da solução.
Quer gastar energia desenhando uma vez o mecanismo que impedirá cem execuções manuais futuras.
Quer pagar o custo cognitivo na origem para colher alívio operacional em escala.
Ele não odeia construir.
Ele odeia reconstruir o mesmo corredor de tijolos todos os dias porque ninguém teve a decência de inventar uma esteira.
Chamaram de preguiça o que muitas vezes era só incapacidade de enxergar sistema.
Nunca foi sobre trabalhar menos; sempre foi sobre usar o cérebro onde ele realmente vale mais.
Vagabundo, mas senior
Quem vem dessa escola é praticamente um vibe coder sênior.
Mas com cicatriz.
Porque já entendeu, apanhando, algumas verdades que o entusiasmo puro ainda está descobrindo.
Automatizar um processo ruim só cria desastre em escala.
Gerar código rápido não significa reduzir complexidade.
Ferramenta sem validação vira máquina de fabricar ilusão.
Abstração ruim não economiza trabalho; ela terceiriza confusão para o futuro.
E o maior sinal de maturidade não é produzir muito código.
É eliminar a necessidade de código, decisão e esforço onde eles não deveriam existir.
O Programador Vagabundo não se impressiona com velocidade sozinha.
Ele quer alavancagem.
Quer recorrência de ganho.
Quer redução estrutural de atrito.
Senioridade, para mim, nunca foi aguentar mais repetição — foi aprender a extingui-la.
Seu compromisso não é com esforço. É com elegância operacional.
Existe uma ética escondida nessa postura.
O Programador Vagabundo respeita o próprio tempo porque respeita o tempo dos outros.
Ele sabe que cada procedimento manual mal desenhado é um imposto invisível cobrado do time inteiro.
Cada repetição que poderia ter sido automatizada é uma forma de dívida operacional.
Cada processo que depende de cuidado artesanal constante já está avisando que falhará em escala.
Por isso ele não quer virar herói do suporte.
Não quer ser o operador brilhante que salva a madrugada.
Não quer aplauso por aguentar a bagunça.
Ele quer construir um sistema em que esse teatro heróico fique desnecessário.
Eu não quero ser o herói da operação; eu quero tornar o heroísmo desnecessário.
O verdadeiro lema
Nunca foi “trabalhar menos”.
Sempre foi:
não trabalhar duas vezes no mesmo problema.
Resolver uma vez.
Encapsular.
Padronizar.
Automatizar.
Validar.
Tornar reprodutível.
Reduzir espaço para erro.
Eliminar dependência de memória, sorte e boa vontade.
Essa é a forma superior de preguiça: a que transforma esforço bruto em estrutura.
Se eu precisei fazer duas vezes, o sistema ainda está incompleto.
A história secreta da computação é a história dessa preguiça
O alias nasceu daí.
O script nasceu daí.
O Makefile nasceu daí.
O pipeline nasceu daí.
O infrastructure as code nasceu daí.
O scaffolding nasceu daí.
O autocomplete nasceu daí.
O codegen nasceu daí.
Os agentes nascem daí.
Por trás de boa parte da evolução prática do software existe a mesma pergunta ancestral:
como garantir que ninguém precise fazer isso manualmente de novo?
Essa pergunta moveu mais progresso real do que muita reunião estratégica com slide bonito.
Foi exatamente desse incômodo com o repetitivo que eu aprendi a transformar trabalho manual em arquitetura.
Contra o culto ao sofrimento técnico
O mercado adora romantizar desgaste.
Adora vender a imagem do profissional sobrecarregado, atolado em contexto, orgulhoso por sustentar processos ruins com esforço pessoal.
Adora tratar exaustão como prova de valor.
Adora confundir complexidade desnecessária com profundidade.
O Programador Vagabundo rejeita esse teatro.
Ele sabe que maturidade técnica não é suportar mais caos.
É reduzir caos sistematicamente.
Não é decorar passos.
É apagar passos.
Não é aceitar fricção como parte inevitável do trabalho.
É perguntar por que essa fricção ainda existe.
Eu não compro essa estética da exaustão: sistema bom reduz atrito, não fabrica martírio.
O futuro sempre foi dele
Agora temos modelos generativos, agentes, orquestração, automação sobre automação, interfaces conversacionais, execução por intenção.
Perfeito.
Mas vamos falar a verdade sem perfumaria: isso tudo caiu como uma luva justamente para quem já tinha o instinto central da coisa.
O Programador Vagabundo já sonhava com esse mundo.
Um mundo em que descrever a intenção vale mais do que executar o ritual.
Um mundo em que a máquina absorve a carga operacional e o humano sobe de nível.
Um mundo em que cérebro não é desperdiçado em tarefa repetitiva.
O hype mudou os instrumentos.
Não mudou o princípio.
A IA só acelerou uma visão que eu já tinha há muito tempo: cérebro humano não foi feito para servir de script manual.
Então assumamos o título
Sim, Programador Vagabundo.
No sentido nobre.
No sentido técnico.
No sentido quase filosófico.
Vagabundo porque se recusa a ser escravo de tarefa repetitiva.
Vagabundo porque automatiza antes de obedecer.
Vagabundo porque prefere pensar melhor a trabalhar pior.
Vagabundo porque quer transformar esforço bruto em sistema reproduzível.
E, no fim das contas, foi esse “vagabundo” que empurrou a engenharia adiante enquanto muita gente aplaudia planilhas, cliques e sofrimento performático.
Se ser vagabundo é automatizar antes de obedecer, então eu assino esse título sem vergonha nenhuma.
Declaração final
Não programamos apenas para fazer software funcionar.
Programamos para remover tarefas que jamais deveriam continuar existindo.
Não automatizamos por fraqueza.
Automatizamos por lucidez.
Não evitamos trabalho por covardia.
Eliminamos desperdício por respeito à inteligência.
E toda vez que um processo manual morre, um script nasce, uma regra impede erro, uma ferramenta comprime esforço e um sistema passa a carregar sozinho aquilo que antes dependia de sofrimento humano, o Programador Vagabundo vence mais uma vez.
Porque ele sempre soube de uma coisa que agora o resto do mercado está começando a perceber:
a forma mais elevada de programar é recusar trabalho burro com sofisticação suficiente para que ele nunca mais volte.
Depois de 24 anos como programador Full Stack Web, minha resposta à repetição deixou de ser esforço e passou a ser arquitetura.
Senior Vibe Coder
Senior Vibe Coder não é o cara que só “usa IA para escrever código mais rápido”.
Isso qualquer um aprende. O ponto de senioridade está em outra camada.
Um sênior consegue atuar em várias frentes ao mesmo tempo porque ele não pensa só em função, tela ou endpoint. Ele pensa em sistema, contexto, trade-off, integração, risco e evolução.
Quando ajuda a IA, ele não está só pedindo código. Ele está guiando arquitetura, validando decisões, quebrando problemas, percebendo acoplamentos ocultos e evitando que a velocidade vire entropia fantasiada de progresso.
Por isso, um sênior não é apenas um escrevedor de código.
Ele é arquiteto e engenheiro de software.
Código é só uma das saídas do raciocínio.
Antes dele vêm modelo mental, desenho de fluxo, critérios de qualidade, estratégia de modularização, observabilidade, segurança, manutenção e escala. A IA pode acelerar a execução, mas ainda precisa de alguém que enxergue o tabuleiro inteiro sem cair no teatrinho do “funcionou na minha máquina” 😅
O verdadeiro senior vibe coder não terceiriza pensamento para a IA.
Ele orquestra a IA em múltiplas direções sem perder coerência técnica.
É isso que separa quem apenas gera código de quem realmente constrói software.
Top comments (0)