Terence Tao é, sem exagero, o maior matemático vivo. Medalha Fields, prêmio Breakthrough, mais de 300 papers publicados. O cara resolve problemas que ninguém no planeta consegue resolver. E na semana passada, ele sentou, abriu um agente de IA e pediu para portar 24 applets Java que ele tinha programado em 1999.

O resultado? A IA fez o serviço em horas. E de bônus, encontrou dois bugs no código original que Tao nunca percebeu em quase três décadas.

Código de 1999: quando Java rodava no navegador

Lá no final dos anos 90, Tao era professor na UCLA e dava aulas de análise complexa e álgebra linear. Para ajudar os alunos a visualizar conceitos matemáticos, ele escreveu dezenas de applets em Java 1.0. Visualizadores de conjuntos de Besicovitch, transformações de Möbius, calculadoras de autovalores, o teorema dos resíduos interativo. Tudo rodando direto no navegador, via Java Plugin.

Se você é novo demais para lembrar, Java Applets foram uma das primeiras tentativas de rodar código interativo no browser. Antes de JavaScript ter Canvas, antes de WebGL, antes do Flash dominar, Java Applets eram a forma de criar algo mais sofisticado que HTML estático. Você escrevia uma classe que estendia java.applet.Applet, empacotava num .jar, e o navegador executava via plugin da JVM.

O problema é que o mundo mudou. Java no navegador morreu. Chrome removeu suporte a NPAPI em 2015. Firefox seguiu em 2017. Safari já tinha abandonado antes. As applets ficaram inacessíveis. Aqueles visualizadores que ajudavam centenas de alunos todo semestre viraram links quebrados numa página da UCLA.

Tao tentou resolver isso por conta própria algumas vezes ao longo dos anos, mas a tarefa era chata. Converter Java para JavaScript manualmente, reescrever a lógica de renderização usando Canvas API, adaptar o handling de eventos do mouse, refazer o layout sem os componentes AWT. Cada applet levaria horas de trabalho tedioso. Com 24 delas na fila, o projeto sempre ficava para depois.

Qualquer dev que já tentou migrar um projeto legado conhece essa sensação. Você sabe que precisa fazer, sabe como fazer, mas o custo em tempo não justifica. Então o projeto apodrece no backlog por anos.

“Pedi para a IA e ela fez em horas”

Em julho de 2026, Tao finalmente atacou o problema. Mas em vez de reescrever tudo na mão, ele usou um agente de IA via “vibe coding”: conversou com o modelo, explicou o que cada applet fazia, mandou o código Java original e pediu a conversão para JavaScript/HTML5.

O agente portou todas as 24 applets em questão de horas.

Eu preciso repetir isso porque é absurdo: 24 programas completos, cada um com lógica de renderização 2D, interação com mouse, cálculos matemáticos complexos, portados de Java 1.0 para JavaScript moderno. Em horas. Não em semanas, não em sprints de duas semanas com daily standup e retrospectiva. Horas.

E não foi um port meia-boca. As applets ganharam upgrades visuais. O visualizador de Besicovitch, por exemplo, agora tem colorização que não existia no original. O honeycomb (co-criado com Allen Knutson nos anos 90) ganhou uma interface mais limpa.

O bug que a IA criou (e os dois que ela achou)

Tao fez questão de testar cada applet portada. Em 24 conversões, encontrou exatamente um bug: um problema no handling de eventos de drag numa das applets de análise complexa. Um bug. Em 24 programas.

A parte realmente interessante vem agora. Durante o processo de conversão, o agente de IA analisou o código Java original linha por linha. E encontrou dois bugs que estavam lá desde 1999. Bugs que Tao nunca tinha percebido.

Pensa nisso por um segundo. O maior matemático do mundo escreveu código em 1999, usou esse código por anos em aulas, e uma IA olhou aquele mesmo código 27 anos depois e disse “ei, isso aqui está errado”.

Tao resume a situação como um “net wash”, um empate: a IA introduziu um bug, mas corrigiu dois. Saldo positivo, na verdade.

O app que Tao queria há 27 anos

Portar applets antigas já seria uma boa história. Mas Tao foi além. Ele pediu para o agente criar algo completamente novo: um editor de diagramas de espaço-tempo para relatividade especial.

Tao descreve essa ferramenta como “Inkscape no espaço de Minkowski”. Um editor visual onde você cria e manipula diagramas de relatividade especial, algo que ele tinha conceituado desde 1999 mas nunca construiu porque a complexidade da implementação não compensava o tempo investido.

Com o agente de IA, ele construiu em horas o que não conseguiu justificar construir em 27 anos.

Ele também criou um visualizador interativo para a conjectura de Gilbreath, que acompanha um paper recente dele. Em vez de colocar gráficos estáticos no paper, Tao agora pode linkar uma ferramenta interativa que os leitores podem manipular.

“Ferramentas auxiliares, não componentes críticos”

Tao não é ingênuo sobre as limitações. No post dele, ele deixa claro que esses applets “são visuais auxiliares, não componentes críticos”. Ou seja: se tiver um bug sutil, ninguém vai basear uma prova matemática no resultado da applet. A verificação formal fica a cargo de outros mecanismos.

Essa distinção é crucial e muita gente ignora. Tao não está dizendo “IA substitui programadores”. Ele está dizendo que para certas categorias de software (visualizações, ferramentas de apoio, protótipos), o nível de risco é aceitável. A IA pode criar bugs sutis? Pode. Mas se o software em questão é uma animação didática e não um sistema de controle de tráfego aéreo, o trade-off vale a pena.

Ele formulou isso de uma maneira elegante em entrevistas anteriores: “o nível de automação que você pode usar antes de virar slop é proporcional ao rigor da sua verificação.” Se você tem como verificar o resultado (testes, revisão manual, comparação com o original), pode usar mais automação. Se não tem, cuidado.

A evolução da visão de Tao sobre IA

Quem acompanha Tao sabe que ele não é um hype man. Em 2023, quando todo mundo estava pirando com o GPT-4, Tao era cauteloso. Disse que IAs eram “assistentes de graduação medíocres” para matemática. Testou, achou limitado, seguiu com a vida.

Mas algo mudou. Em 2026, Tao foi tema de uma matéria na Quanta Magazine com o título “Como Terry Tao se Tornou um Evangelista da IA na Matemática”. Ele dividiu provas entre ele e o modelo, com a IA cuidando de trechos mecânicos enquanto ele fazia as partes criativas. Em um simpósio em Stanford com outros ganhadores da medalha Fields, discutiu abertamente como a IA vai mudar a profissão de matemático.

A frase dele que ficou foi: “a descrição do trabalho está mudando”. Não é que os matemáticos vão ser substituídos. É que o tipo de trabalho manual e tedioso (como portar 24 applets de Java para JavaScript) vai ser delegado. O que sobra é o trabalho que humanos fazem bem: decidir quais problemas valem a pena, julgar se um resultado faz sentido, defender uma prova em público.

O que isso significa para devs

Vamos ser práticos. Se o maior matemático do mundo consegue portar 24 programas com IA em horas, o que isso diz sobre o tipo de código que você escreve no trabalho?

A maioria das tarefas de programação corporativa é infinitamente mais simples que transformações de Möbius em análise complexa. CRUDs, migrations, conversões de formato, testes unitários, refatorações. Se uma IA conseguiu lidar com renderização matemática 2D sem quase nenhum bug, ela consegue lidar com o seu endpoint REST.

Mas repare no que Tao fez que muitos devs não fazem: ele testou cada resultado. Ele revisou. Ele sabe o suficiente sobre o domínio para identificar quando algo está errado. Esse é o ponto que separa “vibe coding que funciona” de “vibe coding que gera 69 vulnerabilidades em 15 apps”.

A automação não substitui competência. Ela amplifica. Tao usou IA porque ele entende profundamente o que aqueles applets deveriam fazer. Se alguém que não entende análise complexa pedisse a mesma conversão, provavelmente aceitaria bugs como features sem perceber.

Pensa nos projetos que você tem engavetados. Aquela refatoração que nunca sai. Aquele script de migração que ninguém quer escrever. Aquele protótipo que você desenhou no caderno mas nunca implementou porque ia levar dois finais de semana. A história de Tao mostra que o cálculo mudou. Projetos que não valiam o investimento em tempo manual podem valer o investimento de uma tarde com um agente de IA.

Mas, e eu não canso de repetir: só se você sabe verificar o resultado.

O repositório está aberto

Todas as applets portadas estão disponíveis publicamente em teorth.github.io/tao-web. Dá para brincar com visualizações de:

São mais de 30 ferramentas interativas. Gratuitas, abertas, funcionando em qualquer navegador moderno. Se você está estudando matemática ou dando aula, é um tesouro.

Vibe coding com verificação: o template que funciona

O workflow de Tao é um modelo que qualquer dev pode copiar:

1. Conheça o domínio. Tao sabe exatamente o que cada applet deveria fazer. Ele não delegou cegamente.
2. Use IA para o trabalho mecânico. A conversão Java para JavaScript é repetitiva. É o tipo perfeito de tarefa para automação.
3. Teste tudo. Um bug em 24 ports. E ele encontrou esse bug porque testou.
4. Aceite que IA vai errar. Mas meça o erro contra o que você teria feito sozinho. Dois bugs no código original de Tao estavam lá há 27 anos.
5. Documente o processo. Tao publicou transcrições das conversas com o agente, mostrando como iterou até chegar no resultado.

Esse é o “vibe coding” que funciona: não é pedir para a IA fazer tudo e rezar para dar certo. É usar IA como um acelerador dentro de um processo que inclui conhecimento, revisão e teste.

Java 1.0 para JavaScript moderno: o que muda na prática

Para quem tem curiosidade técnica, a conversão que o agente fez não é trivial. Java Applets usam o modelo de renderização do AWT: você sobrescreve paint(Graphics g), desenha primitivas com g.drawLine(), g.fillOval(), e o framework cuida do double buffering e do event loop.

Em JavaScript, o equivalente é o Canvas API. Você pega um contexto 2D com canvas.getContext('2d'), desenha com ctx.lineTo(), ctx.arc(), e precisa gerenciar seu próprio loop de animação com requestAnimationFrame. O modelo de eventos também é diferente: Java usa MouseListener e MouseMotionListener como interfaces, JavaScript usa addEventListener com tipos de evento como mousedown, mousemove, mouseup.

// Java 1.0 (1999)
public class BesicovitchApplet extends Applet
    implements MouseListener {
    public void paint(Graphics g) {
        g.setColor(Color.blue);
        g.fillOval(x, y, 10, 10);
    }
}

// JavaScript (2026, gerado por IA)
const canvas = document.getElementById('besicovitch');
const ctx = canvas.getContext('2d');

function draw() {
    ctx.fillStyle = '#3498db';
    ctx.beginPath();
    ctx.arc(x, y, 5, 0, Math.PI * 2);
    ctx.fill();
    requestAnimationFrame(draw);
}

A estrutura muda, a API muda, os idioms mudam. Mas a lógica matemática por baixo (as coordenadas, os cálculos, as transformações) é a mesma. E é exatamente esse tipo de conversão que agentes de IA fazem bem: traduzir de um “dialeto” para outro mantendo a semântica.

O matemático que programa como dev

Tem algo poético nisso tudo. Em 1999, Tao era um matemático de 24 anos escrevendo Java para ajudar alunos a entender análise complexa. Em 2026, aos 51, ele está usando IA para ressuscitar esse mesmo código, e de quebra construindo ferramentas que não conseguiu justificar construir em quase três décadas.

O código mudou. A linguagem mudou. O navegador mudou. Mas o problema que Tao queria resolver (“como ajudar pessoas a visualizar matemática”) é o mesmo. A IA não mudou o problema. Mudou o custo de resolver.

E quando o custo cai o bastante, projetos que ficaram parados por 27 anos finalmente saem do papel.

Quer testar? As applets estão em teorth.github.io/tao-web. O post original do Tao, com transcrições das conversas com o agente, está no blog dele.

Fonte de inspiração: Old and new apps, via modern coding agents, por Terence Tao