Eu ainda lembro da sensação de escrever minha primeira função aos 10 anos — era pura diversão. Hoje eu me pego perguntando: programar ficou chato? Entre prompts que escrevem código, agentes que fazem commits e aquisições bilionárias, a rotina dev mudou rápido demais. Neste post eu misturo dados, experiências pessoais (sim, eu uso IA nos meus projetos) e um pouco de inquietação sobre para onde vamos.
1) O novo fluxo: prompts no centro do desenvolvimento
Eu me peguei fazendo uma pergunta que parece proibida entre devs: “Programar ficou chato?” Não porque eu deixei de gostar de criar coisas, mas porque o meu dia mudou. Antes era teclado, função, teste, refatoração. Agora, muitas vezes, é: escrevo um prompt, espero 10 ou 20 minutos, reviso um trecho, peço ajuste, e repito. A codificação alimentada IA virou um loop curto e iterativo — e, sinceramente, isso mexe com a cabeça.
Do “escrever código” para “dirigir a saída”
O fluxo mais comum hoje parece um funil:
Eu descrevo o que quero em linguagem natural (regras, contexto, restrições).
A IA gera código, testes, migrações, docs.
Eu valido: leio diffs, rodo testes, caço edge cases.
Eu realimento com correções e mais contexto.
É aqui que entram as ferramentas IA desenvolvedores: editores com agente, CLI com modelo, bots que abrem PR, e até automações internas que sugerem quem precisa revisar cada módulo. O teclado ainda existe, mas ele virou mais “controle de qualidade” do que “linha por linha”.
Prompts como nova interface (e a criatividade mudando de lugar)
Eu concordo com uma coisa: a parte mais legal sempre foi criar. Só que a criatividade do dev, que antes saía em linhas de código, agora sai em prompts. Eu escolho o que pedir, como pedir, quais exemplos dar, quais limites impor. Isso é a tal engenharia contexto ascensão: não é só “prompt bonitinho”, é montar o cenário certo para a IA não alucinar e não quebrar o sistema.
“A engenharia de software está mudando, e estamos entrando em um novo período na história da codificação.” — Boris Cherny
Trabalho vs. projetos pessoais: o conflito
Eu ainda escrevo muito código, principalmente em projetos pessoais. E eu programo desde os 10 anos, então tem um lado emocional aqui: eu gosto de codar. Só que no trabalho a pressão é outra: velocidade, entrega, custo. A IA entra como padrão, e o meu papel vira mais “orquestrar” do que “digitar”.
O risco: IA como bengala
O perigo é tratar a IA como desculpa. Se eu não validar, eu viro passageiro. Por isso eu tento manter regras simples:
Nada entra sem teste, lint e leitura de diff.
Prompt sem contexto é loteria: eu sempre passo restrições e exemplos.
Se eu não consigo explicar o código gerado, eu não aprovo.
2) Evidências reais: dados, casos e sinais (Stack Overflow, Boris, aquisições)
O gráfico do Stack Overflow e a mudança de hábito
Eu sei que “sensação” engana, então eu gosto de olhar pra dado público. E o gráfico de perguntas mensais do Stack Overflow é um sinal bem direto: em 2023–2024 a gente bateu o ponto mais baixo em anos. Pra mim, isso não significa que todo mundo virou gênio do nada. Significa que o fluxo mudou: em vez de abrir uma aba e perguntar “por que meu NullPointer acontece?”, a galera pergunta pra IA, ajusta o prompt e segue.
Esse é um dos melhores termômetros das tendências IA 2026: menos busca pública, mais conversa privada com modelos e agentes.
Boris Cherny e o Claude Code: quando o agente vira “mão de obra”
Outro sinal forte é quando gente muito boa, com acesso ao estado da arte, descreve o novo padrão de trabalho. O Boris Cherny (Anthropic) contou que criou o Claude Code como projeto paralelo em setembro de 2024. E o que me pega não é a ferramenta em si, é a escala e a estabilidade.
259 pull requests em 30 dias
497 commits
40.000 linhas adicionadas e 38.000 removidas
Tudo escrito com Claude Code + Opus 4.5
“O Claude rodou consistentemente por minutos, horas e dias, usando stop hooks.”
Isso encaixa perfeito no que eu vejo como previsões IA 2026: agentes que não só sugerem, mas executam ciclos inteiros (planejar, codar, testar, abrir PR) por horas ou dias.
Aquisições e a corrida por orquestração
Quando a Meta compra a Manus AI por mais de US$ 2 bilhões (com US$ 100 milhões de receita anual), eu leio como: “não é só modelo, é orquestração de múltiplos agentes e talento”. É o mercado dizendo que o diferencial vai ser coordenar agentes como se fossem times.
xAI e a fábrica IA infraestrutura
E aí vem a parte mais “industrial”: a xAI levantando US$ 20 bilhões (Série E) com NVIDIA e apostando em data centers próprios (Colossus I e II), mirando mais de 1 milhão de H100 equivalentes até o fim de 2025. Isso é fábrica IA infraestrutura: quem controla computação em escala controla velocidade de treino, custo e, no fim, produto.
Com esse nível de investimento, não é hype: é corrida armamentista.
3) Ferramentas práticas e recomendações (Claude, Grok, HiGlobe e workflow)
Ferramentas IA desenvolvedores: onde Claude Code e Grok 4 realmente me salvam
Eu uso Claude Code quase todo dia. Ele brilha quando eu preciso mexer em base grande, criar PRs com mudanças consistentes e manter contexto por mais tempo. Nos últimos meses, virou normal eu pedir: “mapeia esse módulo, propõe a refatoração e já abre o PR com testes”. E é aqui que eu sinto os ciclos desenvolvimento minutos: eu saio de “ideia” para “primeiro PR revisável” muito mais rápido.
“Boa parte do código que escrevi nos últimos dois meses foi através de um agente de IA.” — eu
Já o Grok 4 eu uso como segundo cérebro quando Claude/GPT estão lentos ou quando eu quero uma visão diferente do problema. Ele não é meu “gerador principal de código”, mas é ótimo para destravar: arquitetura, trade-offs, edge cases, e perguntas do tipo “o que eu não estou vendo?”.
“Grok sempre me dá uma nova perspectiva quando outros modelos estão lentos.” — relato pessoal sobre Grok 4
Workflow com agentes: apps sob demanda empresas e revisão por commit
O pulo do gato não é só “usar IA”, é operacionalizar. Aqui a gente criou agentes internos que:
identificam quem é dono de cada módulo;
geram mudanças em branches separados;
abrem PRs e pedem revisão commit-a-commit para o time certo.
Um prompt simples que uso como base:
Leia o diff. Liste módulos afetados, donos prováveis, riscos, testes necessários e sugira reviewers. Depois, quebre em commits pequenos.
Protocolos: IA não é muleta
Defina “done”: testes, lint, build, e checklist de segurança.
Valide por camadas: unit + integração + smoke em staging.
Revise intenção: o PR precisa explicar o “porquê”, não só o “o quê”.
4) Cultura, carreiras e o fim da 'divisão técnica'
Eu sinto que a mudança mais forte não é nem a ferramenta em si. É a cultura que vem junto. Antes, existia uma “divisão técnica” bem clara: quem escreve código “de verdade” versus quem só pede coisa. Só que, quando todo mundo passa a trabalhar com workflows IA agentes, essa linha começa a sumir. O que vale não é mais “quem digitou”, e sim quem entregou com qualidade.
Promoção e avaliação viram “prova de uso de IA”
Isso já está aparecendo em empresas grandes. O caso mais citado é a Shopify, com a frase que virou um símbolo dessa virada:
“Para ser promovido, você precisa demonstrar o que criou com IA.”
Na prática, o critério de carreira muda: não basta ser bom em arquitetura ou em escrever testes. Você precisa mostrar que sabe usar IA como genAI organizacional recurso — do jeito certo, no contexto certo, com rastreabilidade.
Produtividade sobe, mas a responsabilidade não some
Tem uma pressão real por velocidade. E quando o time percebe que dá pra fazer em horas o que levava dias, a adoção vira padrão. Só que tem uma parte que muita gente tenta esquecer:
“Você ainda será culpado se entregar algo com baixa qualidade.”
Ou seja: IA não vira desculpa. Se o bug foi parar em produção, se o dado vazou, se a UX ficou ruim, o “foi o modelo” não cola. A empresa quer resultado pro cliente final, bem na linha do discurso do Satya Nadella: menos debate sobre “slop”, mais foco em satisfação do usuário.
O dev vira orquestrador, validador e dono do contexto
O meu trabalho (e o de colegas bem seniores) está mudando de “implementar” para orquestrar. A gente cria prompts internos, agentes que entendem módulos, e rotinas de revisão por área. O valor passa a ser:
Engenharia de contexto: dar ao agente o que ele precisa (regras, limites, exemplos, dados).
Curadoria de prompts: manter prompts vivos, versionados, testados, como se fossem código.
Validação: revisar PR, checar impacto, garantir segurança e consistência.
Pra mim, isso é o fim divisão técnica: não existe mais “quem programa” e “quem pede”. Existe quem domina o sistema inteiro — código, produto e agentes — e quem fica só apertando botão.
O lado emocional: quando o prazer de programar vira saudade
Eu não vou fingir que é neutro. Tem um luto pequeno aí: a alegria de escrever código, de entrar em flow, de lapidar uma solução. Agora eu passo mais tempo conversando, revisando, guiando. Dá uma sensação de que eu preciso reaprender meu próprio papel — e aceitar que “programar” virou, muitas vezes, dirigir máquinas que programam.
5) Olhando adiante: padrões, riscos e um dilema pessoal
Eu fico voltando numa comparação que não sai da minha cabeça: o que estamos vivendo agora parece a adoção do Fortran nos anos 50. Naquela época, a galera saiu do “falar com a máquina” no nível mais baixo e deu um salto de abstração. Hoje, o salto é parecido, só que mais radical: a gente está saindo de linguagens de alto nível e indo para prompts, linguagem natural e agentes que trabalham por horas.
“Estamos vivenciando algo que talvez a última vez que aconteceu foi na década de 50, com a criação do Fortran.”
tendências IA 2026: o que vira padrão de verdade
Se eu tivesse que apostar, 2026 é quando os workflows com IA deixam de ser “experimento” e viram processo oficial. As tendências IA 2026 apontam para times criando uma camada nova de trabalho: menos “escrever função”, mais “desenhar contexto, validar e auditar”. É aí que entram protocolos e ferramentas que hoje ainda são improviso.
Protocolos de validação: checklist de testes, revisão por módulo, rastreio de decisões do agente e critérios de rollback.
Ferramentas de análise de repositório: agentes que entendem donos de código, impacto por pasta, histórico de bugs e padrões de PR.
Engenharia de contexto: manter “janelas de contexto” consistentes, com regras, exemplos e limites claros.
próximas IA 2026 e a fábrica IA infraestrutura
Outra coisa que muda tudo é a escala. Quando eu leio sobre data centers gigantes e clusters que viram quase uma “usina”, eu entendo por que tanta gente fala em fábrica IA infraestrutura. Não é só modelo melhor: é capacidade de rodar agentes continuamente, com custo previsível e governança. E com apostas tipo Colossus I e II e a ideia de passar de 1.000.000 H100 equivalentes até o fim de 2025, dá para sentir o empurrão.
riscos macro: bolha, poder e perda de ofício
Eu também vejo riscos grandes. Pode rolar uma bolha e depois uma deflação feia. Pode rolar centralização ainda maior nas Big Techs (modelo, dados, infraestrutura, distribuição). E tem o risco mais silencioso: perder o ofício manual. Se eu não pratico, eu desaprendo. Se eu desaprendo, eu viro só operador de ferramenta.
meu dilema: empolgação vs. saudade
Eu estou dividido. “É preocupante, mas empolgante ao mesmo tempo.” Empolgante porque novos padrões vão nascer. Preocupante porque eu programo desde os 10 anos e gosto do ato de escrever código. Só que, do jeito que está indo, o “código” vira mais um detalhe — e eu ainda não sei como me sinto com isso.
6) Wild cards: cenários estranhos e anedotas para provocar pensamento
2030: “escreve minha autobiografia de código”
Às vezes eu tento imaginar o futuro pra além do hype. Um wild card que não sai da minha cabeça: em 2030 eu vou abrir o chat e pedir pro meu agente: “escreve minha autobiografia de código”. Não no sentido poético, mas prático: ele vai varrer meus repositórios, entender minhas decisões, mapear meus erros repetidos, e… submeter PRs por mim. Eu só aprovo. Talvez eu nem saiba mais onde fica a pasta /src. E isso é assustador e útil ao mesmo tempo.
O ponto desses cenários extremos não é prever o futuro com precisão. É usar o exagero pra planejar mitigação de riscos hoje: se agentes IA autônomos virarem rotina, o que acontece quando eles erram em escala? Qual é o “freio de mão” do time? Onde fica o botão de parar?
De guitarrista pra DJ: técnica muda, expressão continua
Pra mim, programar por prompts é como passar de guitarra pra DJ. Na guitarra, você sente cada corda. No DJ, você orquestra camadas, transições, energia. A técnica muda, mas a expressão continua. E talvez o nosso papel vire isso: ser compositores IA todos, regendo agentes, dados, testes e intenção.
Fechamento: um teste pequeno, um hábito grande
Se eu deixo uma chamada à ação, é simples: teste seu fluxo com um pequeno agente esta semana. Faça um experimento controlado, com escopo curto, e documente 5 falhas comuns que aparecerem. Depois, transforme isso em checklist de validação do time.
