On July 11, Terence Tao — Fields Medalist, UCLA professor, and author of more than 400 research papers — published a blog post documenting a multi-day experiment in which he used AI coding agents to resurrect Java 1.0 applets he had written in 1999, then built an entirely new special-relativity visualization tool he had started and abandoned 27 years ago. By the following morning, the post was the top story on Hacker News. What makes it worth reading is not the viral attention. It is the calibration framework Tao applied when deciding whether to trust the output — a framework that turns out to be identical to the one sound engineering governance has been preaching for two years.

Dead Code, Resurrected in Hours

Tao's experiment started with a problem that any engineering team with more than a decade of software history will recognize immediately. In 1999, he built a suite of Java 1.0 applets to help teach complex analysis and linear algebra — interactive visualizations of honeycombs, Besicovitch sets, and other abstract mathematical objects. The applets ran well inside browsers for years. Then the web moved on, browser support for Java dried up, and the tools went dark.

The resurrection story is striking for its speed and its bug count. Tao asked an AI coding agent to port the old applets to JavaScript — the modern equivalent of the canvas-rendering environment Java's Abstract Window Toolkit once occupied — and the agent completed the work in a matter of hours. All of his interactive applet collection was functional again, including a colorized version of the Besicovitch set that replaced his original monochrome rendering. He was particularly pleased to see the honeycomb visualization he had co-written with Cornell mathematician Allen Knutson in 1999 come back to life, describing it as one of the trickier applets to code by hand.

Then Tao counted the bugs. Across the two dozen or so ported applets, he found one — unwanted behavior when dragging outside the boundary of a complex analysis applet's main display area. But the agent also identified two bugs in his original 1999 code that he had not previously noticed. The net outcome was a bug credit: the AI-assisted port improved code quality compared to the source. Tao noted explicitly that the downside risk was low because the applets are secondary visual aids rather than components of a mathematical argument. If a drag event misbehaves, a viewer notices and adjusts. A broken proof is a career event.

That distinction is the entire framework.

The Transpilation Problem That Agents Can Now Solve

The technical challenge of porting Java 1.0 applets to JavaScript is not simply translation between two programming languages. Java's Abstract Window Toolkit used a retained-mode graphics model — objects were described once and managed by the runtime. Modern JavaScript visualization uses the HTML5 Canvas API's immediate-mode model — the rendering loop draws to a pixel buffer on every frame. An agent porting across these two paradigms must parse Java AWT drawing calls, identify the mathematical objects being rendered from the code's structure, translate rendering primitives to Canvas API equivalents, rewrite the event-handling system from Java's mouse listener model to JavaScript's DOM event model, and then test by execution.

That Tao's agent handled this for 24 applets in a few hours, with a net bug improvement, is a specific and verifiable technical result. It is also an indicator of what has changed in AI coding infrastructure since 2023. The tools Tao drew on — including Claude Code, which the JetBrains AI Pulse survey found had recorded a jump from roughly 3% workplace adoption in mid-2025 to 18% by January 2026, a sixfold increase no developer tool had achieved in that timespan — operate as terminal-based agents rather than inline suggestion engines. They read entire codebases, execute shell commands, modify files across multiple paths, and iterate based on observed results. The unit of work is a task, not a line.

Inkscape in Minkowski Space, Finally

The most vivid section of Tao's post involves a project he had abandoned decades earlier. In 1999, he conceived a special-relativity visualization tool — essentially, in his words, "Inkscape, but in Minkowski space," a drawing environment where geometric objects obey Lorentz transformations rather than Euclidean geometry. He had begun writing Java code for it. The code complexity exceeded what he could manage at the time, and the project stalled. It sat unbuilt for 27 years.

After a few hours of guided interaction with an AI agent, a working version of the spacetime diagram applet now exists. Tao also published an edited conversation transcript of the exchange he had with the agent to produce it, offering a rare record of the actual back-and-forth: conceptual direction and domain knowledge supplied by the human; implementation handled by the agent; iterative review and correction by the human. He ran the same workflow to build a Gilbreath conjecture visualization to accompany a paper he published the same day, and published that transcript as well.

The transcript-keeping is not incidental. It is the audit trail.

When to Trust the Agent — Tao's Rule, Stated Precisely

Tao has been documenting his evolving position on AI for the past two years, and the coding agent experiment fits a consistent pattern. In September 2024, after testing an earlier OpenAI model on difficult mathematical problems, he described the experience as working with a mediocre but not completely incompetent graduate student. By March 2026, speaking at an IPAM conference on accelerating mathematics with AI, he had moved his assessment to "ready for primetime" — because in mathematics and theoretical physics, AI now saves more time than it wastes, as OpenAI Academy's coverage of the conference documented.

The progression from skepticism to conditional enthusiasm tracks a specific technical development: the widening of the task categories Tao can confidently delegate. At Stanford's Future of Mathematics Symposium in May 2026, he stated the governing principle directly: the level of automation and AI power a researcher can profitably use before it becomes worthless is roughly proportionate to how stringent their verification process is, as Winbuzzer's symposium coverage reported.

Applied to the coding experiment, the principle maps cleanly. Interactive visualizations have a built-in verifier: human eyes, running the applet, noticing when something looks visually wrong. A Besicovitch set rendered incorrectly is immediately apparent to a mathematician who knows what a Besicovitch set looks like. A Minkowski-space Lorentz transformation drawn incorrectly produces shapes that violate known relativistic behavior. The verification is fast, the failure is visible, and the stakes are bounded. Those three conditions — fast, visible, bounded — are exactly the conditions under which Tao's framework licenses agent use.

What Mathematicians Discovered That Engineers Already Knew

This is where the article's largest unstated implication becomes worth naming explicitly. Tao's fast-visible-bounded verification framework is not an insight unique to mathematics. It is structurally identical to the risk-commensurate AI deployment principle that engineering governance frameworks have been articulating since late 2024 — the principle behind Superpowers, gstack, and GSD, the three open-source discipline frameworks that together accumulated nearly 400,000 GitHub stars by May 2026. All three frameworks resolve to the same core rule: the appropriate level of AI agent autonomy is a function of how quickly and reliably a failure would be detected and corrected.

The world's most rigorous mathematician, working from first principles on a specific experimental problem, independently derived the same governance principle that enterprise software engineering reached from the opposite direction. That convergence is not a coincidence. It is a signal that the principle is correct.

In November 2025, Tao collaborated with Google DeepMind to test the AlphaEvolve system across 67 challenging mathematical problems, documenting in arXiv paper 2511.02864 that the AI excelled at discovering mathematical constructions that were within reach of existing methods but had not yet been found due to the time and effort required. He noted at the time that designing a non-exploitable verifier for the results still required substantial human effort — the verification problem was real even when the construction problem was solved. That observation maps directly to the coding context: agent output that is fast to verify (running an applet) is fundamentally different in risk profile from agent output that requires deep expertise to evaluate (a mathematical proof, a security-critical code path).

Quanta Magazine's April 2026 feature on AI in mathematics quoted Tao's assessment of 2025: it was the year when AI really started being useful for many different tasks. Mathematicians who had dismissed AI models as too error-prone found that the tools could help break genuinely new ground. The Hacker News reaction to Tao's July 11 post reflected what happens when a figure with authority in both mathematics and software engineering speaks directly to a developer community: one commenter summarized the moment by noting that even Tao now faces the same class of AI-assisted debugging problems as any developer trying to get a container to start.

Why Legacy Code Is the Right Target

There is a practical implication worth drawing out explicitly for engineering teams. Tao's Java applets from 1999 are a near-perfect analogy for the internal tools that most software organizations carry in their codebases: functional once, bit-rotted to a dead runtime, not worth the engineering cost to rewrite from scratch, but genuinely valuable if they could run again. The Java 1.0 to modern JavaScript migration is representative of a class of problems — Python 2 to Python 3, older internal frameworks to modern equivalents, proprietary DSLs to open-source alternatives — where the problem is well-defined, the source and target behaviors are testable, and a human expert can verify correctness quickly by observing the output.

The fact that a Fields Medalist with no professional obligation to maintain legacy software found the migration painless, and came out with a net bug improvement, is a data point with direct enterprise implications. The economics of legacy code migration have always been dominated by the cost of senior engineer time. If agents can handle the mechanical layer of cross-language transpilation — and Tao's experiment is one piece of evidence that they can — the bottleneck shifts to the verification layer: do you have someone who can run the output and recognize a correct result when they see it?

Three principles emerge from Tao's workflow that translate across domains.

First, triage by stakes. The agent was used for code whose failure modes are visible and bounded — a broken drag event in a visualization, not a broken mathematical argument. Mapping task categories by downside risk before deploying an agent is the governance work that makes AI adoption sustainable.

Second, preserve the transcript. Tao published the conversation logs for both the relativity applet and the Gilbreath conjecture visualization. In a professional engineering context, that log is the audit trail — the record of which decisions were human and which were delegated, and the evidence base for debugging when something goes wrong later.

Third, treat legacy code as a target-rich environment. Most software organizations have more dead-runtime code than they have resources to migrate by traditional means. The agent's capacity to port code across language generations — with a net improvement in bug count in Tao's case — suggests a specific, high-value use case that is currently underexploited in enterprise settings.

Tao's original blog post is available at terrytao.wordpress.com. The full suite of interactive applets — including the revived honeycomb tool, the colorized Besicovitch set, and the new spacetime diagram — is live at his interactive applet collection.

Frequently Asked Questions

Is what Tao did actually "vibe coding"?

Only in the loosest sense. Tao uses the term himself, but his practice departs from the strict technical definition in important ways. The term "vibe coding" — coined by Andrej Karpathy in February 2025 and named Collins Dictionary's Word of the Year for 2025 — describes a workflow where a developer accepts AI-generated code without reading or reviewing it, and cannot explain how the resulting code works. Tao did the opposite: he identified a specific bug, published detailed transcripts of his sessions, and applied an explicit risk framework before deploying the agent. Developer Simon Willison's widely cited definition holds that if you reviewed the output, tested it, and could explain it to someone else, that is not vibe coding — that is just software development. Tao's experiment is software development assisted by AI agents.

How does an AI agent actually port code from Java 1.0 to JavaScript?

The challenge is not just translating syntax. Java 1.0 applets rendered graphics using the Abstract Window Toolkit's retained-mode model, where graphical objects persist and are managed by the runtime. Modern JavaScript uses the HTML5 Canvas API's immediate-mode model, where rendering logic draws to a pixel buffer each frame. An agent porting between them must parse AWT drawing primitives, identify the mathematical objects being rendered from the code's structure, rewrite rendering in Canvas API terms, and replace Java's event listener system with JavaScript's DOM event model. The agent then runs the code, observes the output, and iterates. Tao's verifier was his own mathematical expertise: a Besicovitch set or honeycomb rendered incorrectly is immediately apparent to someone who knows what those objects look like. The full set of ported applets is viewable at his interactive applet collection.

What is Tao's rule for deciding when to trust AI-generated code?

Tao's framework, which he articulated most precisely at Stanford's Future of Mathematics Symposium in May 2026, is that the level of AI automation you can profitably use is roughly proportionate to how stringent your verification is. Applied to code: use AI agents for tasks where failures are fast to detect, visible to a domain expert, and bounded in consequence before they propagate. Do not use them for tasks where failures are hard to detect, require deep expertise to recognize, or have high propagation risk. For interactive visualizations built as paper supplements, all three conditions favor agent use. For a security-critical payment processing path, none of them do. The framework is not specific to mathematics — it is structurally identical to the risk-commensurate deployment principle that enterprise AI governance frameworks arrived at independently. The full context of this principle appears in Tao's blog post from July 11.

Why does legacy code migration specifically suit AI coding agents?

Legacy code migration has always been economically unattractive because it requires senior engineer time to understand code written for a dead runtime, rewrite it for a modern target, and verify the output is correct. AI agents change the first two legs of that problem: they can read the source, understand intent from code structure and mathematical context, and produce a modern equivalent with fewer bugs per unit of effort than manual rewriting. The third leg — verification — remains human, but it is often the cheapest part if the right domain expert reviews the output. Tao's 27-year-old Java applets represent a universally recognized category of engineering debt. His finding that an agent ported two dozen with a net bug improvement is the most credible piece of evidence yet that legacy migration is a high-value, underexploited use case for AI agents in enterprise settings.