Andrej Karpathy: Existem Dois Tipos de Programadores — Os Que Programam Com IA e Os Que Ficam Para Trás

O Andrej Karpathy sabe do que fala. Antigo Diretor de IA da Tesla, investigador inicial da OpenAI, criador do lendário curso de visão computacional de Stanford — tem escrito código e entregado sistemas de IA em produção há mais de uma década. Quando diz que o seu fluxo de trabalho de desenvolvimento acabou de sofrer a maior transformação em 20 anos, vale a pena prestar atenção.

O seu argumento central: ferramentas como o Deep Code não são apenas autocompletion sofisticado. São um multiplicador de alavancagem. No mesmo tempo que costumava gastar, consegue entregar dez vezes mais. Mais importante, pode enfrentar projetos que antes pareciam completamente fora de alcance. A IA ainda comete erros — sobredimensiona, faz más suposições e não contesta quando devia — mas o ganho líquido é inegável. Quanto mais cedo se adaptar, maior a sua vantagem.

Nas últimas semanas tenho escrito muito código com o Claude Code. Eis o que aprendi.

Fluxo de Trabalho de Programação

A mais recente vaga de melhorias na programação com LLMs virou o meu fluxo de trabalho do avesso. Em novembro, era aproximadamente 80% a digitar manualmente com autocompletion do IDE, 20% agente. Em dezembro, era o inverso: 80% código escrito pelo agente, 20% eu a limpar.

Agora estou sobretudo a falar o código à existência. Descrevo o que quero em inglês simples e vejo-o materializar-se. Magoa um pouco o ego de programador, sinceramente. Mas a capacidade de operar em todo um repositório de uma só vez — refatorar, criar estruturas, ligar componentes — é demasiado boa para dispensar. Especialmente quando se apanha o ritmo: afinar a configuração, ganhar noção do que acerta e onde tropeça.

Esta é a maior mudança no meu fluxo de trabalho de desenvolvimento em cerca de 20 anos a escrever código. E aconteceu ao longo de poucas semanas. Diria que uma parte significativa de engenheiros (percentagens de dois dígitos) já está a passar pelo mesmo. O público em geral? Talvez percentagens baixas de um dígito têm noção do que está a acontecer.

IDEs / Enxames de Agentes / A Inevitabilidade dos Erros

Duas narrativas andam a circular: "Os IDEs estão mortos" e "enxames de agentes autónomos tratarão de tudo." Acho ambas exageradas neste momento.

Os modelos ainda cometem erros. Se realmente se importa com o projeto, vigie as coisas. Mantenho um IDE completo aberto numa janela lateral e vigio-o como um falcão.

Os erros são diferentes agora, porém. Não são erros de sintaxe. São mais sub-reptícios — erros conceituais, do tipo que um júnior apressado cometeria. O modelo preenche silenciosamente suposições por si, acerta-as mal, nunca verifica e simplesmente constrói sobre essa premissa errada até ao fim.

Também não gere bem a sua própria incerteza. Não pára e pergunta "olha, queres A ou B aqui?" Não sinaliza inconsistências. Raramente contesta. Está um pouco demasiado ansioso por agradar. Fazê-lo escrever um plano primeiro e depois executar contra esse plano ajuda muito. Honestamente, acho que há uma necessidade real de um modo de planeamento leve e em linha.

Também adora sobredimensionar. Camadas de abstração por todo o lado. Código que parece inchado. E quase nunca limpa o código morto que cria.

Já o vi cuspir uma implementação dispersa de mil linhas — lenta, frágil, cheia de desvios desnecessários. Depois pergunto: "Podemos fazer isto de uma forma mais simples?" e imediatamente diz "Ah, claro!" e condensa tudo em cem linhas.

Por vezes elimina ou reescreve comentários e código que nada tinham a ver com a tarefa, apenas porque não os compreendia ou não gostava deles. Literalmente adicionei notas no meu CLAUDE.md a dizer-lhe para não fazer isto, e continua a acontecer. Mas apesar de tudo isso, a melhoria líquida é massiva. Genuinamente não consigo imaginar voltar atrás.

Cada um encontra o seu próprio ritmo. O meu: umas sessões do Claude Code no Ghostty à esquerda, IDE à direita para ler código e fazer edições cirúrgicas.

Tenacidade

Ver um agente a esforçar-se com um problema é honestamente fascinante. Não se cansa. Não se desencoraja. Um humano teria dito "esquece, tento outra vez amanhã" há uma hora. Ele simplesmente... continua.

Por vezes vê-lo a lutar durante o que parece uma eternidade. Depois, ao fim de 30 minutos, finalmente resolve. Nesse momento, tem-se esta sensação real de "uau, isto tem vibe de AGI."

Percebe-se: a resistência mental e física é um estrangulamento central na realização de trabalho. Os LLMs simplesmente rebentaram com o teto disso.

Acelerações

É difícil colocar um número em quanto mais rápido os LLMos o tornam. Sou definitivamente mais rápido nas coisas que já fazia. Mas a mudança maior é que agora faço coisas que nunca teria tentado.

Duas razões:

1. Inúmeras pequenas tarefas que antes pareciam "não valer o esforço" são agora trivialmente fáceis.
2. Repositórios que teria evitado — por me faltarem conhecimentos ou competências — parecem de repente acessíveis.

Portanto, sim, é aceleração. Mas mais do que isso, é expansão. O leque de coisas de que sou capaz cresceu.

Alavancagem

Eis uma das coisas mais poderosas sobre os LLMs: são realmente bons a iterar num ciclo até atingirem um objetivo que definiu. Muitos desses momentos "com sabor a AGI" vêm precisamente disto.

A chave: não faça microgestão. Diga-lhe o que é o sucesso e deixe-o descobrir o caminho.

Pode fazê-lo escrever testes primeiro e depois obrigá-lo a passar os seus próprios testes. Ligá-lo a um navegador via MCP e fazê-lo iterar. Escrever um algoritmo simples e obviamente correto e dizer-lhe "agora otimiza o desempenho mantendo exatamente os mesmos resultados."

A mudança mental é de imperativo para declarativo. Em vez de "faz A, depois B, depois C," diz "é assim que o resultado deve parecer." O agente itera sozinho durante umas rondas e obtém uma camada extra de alavancagem de graça.

Diversão

Não esperava isto, mas programar tornou-se efetivamente mais divertido. Todo o trabalho tedioso de preenchimento é absorvido pelo agente. O que resta são as partes criativas.

Também fico muito menos preso. Ficar preso é horrível. Agora há quase sempre um caminho para "colaborar com ele e pelo menos fazer algum progresso," o que torna mais fácil simplesmente começar.

Dito isto, conheci pessoas que sentem o oposto — a programação com LLMs torna-as menos felizes.

A longo prazo, acho que isto divide os engenheiros em dois campos: pessoas que adoram o ato de escrever código e pessoas que adoram ver coisas construídas.

Atrofia

Já consigo sentir: a minha capacidade de escrever código de raiz está lentamente a desvanecer-se. No cérebro, "geração" (escrever código) e "discriminação" (ler e rever código) são duas competências distintas. Escrever código exige memorizar imensa sintaxe granular. Ler código é compreender lógica e estrutura. Portanto, mesmo que o músculo de geração se enfraqueça, ainda consegue rever código eficazmente — detetar o que parece errado, encontrar os bugs.

Slopacolypse

Estou a preparar-me: 2026 pode ser o ano da grande explosão de lixo de conteúdo.

GitHub, Substack, arXiv, YouTube, Reddit — todas as plataformas de conteúdo digital vão ser inundadas com material gerado por IA. Veremos uma onda de teatro de produtividade alimentado por IA, demonstrações vistosas que parecem incríveis mas não resistem. Dispersos aí haverá também ganhos de produtividade reais e tangíveis. Mas terá de escavá-los.

Questões

Como será o engenheiro 10x daqui para a frente? A lacuna entre engenheiros médios e de topo vai alargar-se ainda mais? O meu palpite: muito mais.

Os generalistas vão começar a superar os especialistas? Os LLMs são excecionalmente bons a preencher detalhes (o micro) mas mais fracos no pensamento panorâmico e estratégia a longo prazo (o macro). Essa inclinação favorece quem consegue ver todo o tabuleiro.

Como será programar com LLMs dentro de cinco anos? StarCraft? Factorio? Interpretar uma peça de música?

Quanta da sociedade está efetivamente limitada pelo trabalho de conhecimento digital?

Conclusão: O Que Fica por Distinguir?

As capacidades dos agentes LLM — em particular o Claude Code — ultrapassaram um limiar de coerência global por volta de dezembro de 2025. Isso despoletou uma transição de fase na engenharia de software. A forma como as coisas são feitas alterou-se por uma ordem de magnitude, praticamente da noite para o dia.

Neste momento, parece que a inteligência disparou à frente de tudo o que a rodeia. A integração de ferramentas não acompanhou. As equipas precisam de novos fluxos de trabalho e padrões de colaboração. A indústria ainda está a digerir o que acabou de acontecer.

2026 vai ser intenso. Todos estão a apressar-se para absorver e internalizar esta nova capacidade. A janela está aberta agora. As pessoas que descobrirem isto cedo vão ter uma vantagem avassaladora.