Coding agents are best when the expert stays in the loop
Terence Tao revived old Java applets with a coding agent. The lesson for operators is expert-led modernization, not unsupervised autonomy.
Terence Tao’s coding-agent experiment is easy to misread.
The shallow version is that a world-class mathematician used AI to rebuild old Java applets in a few hours. Nice productivity story. Put it on the pile.
The useful version is sharper: coding agents are becoming good at reviving valuable old software when a domain expert can define the target, inspect the output, and catch the boundary cases.
That is a different lesson from “AI writes code now.” It is closer to this: AI can turn expert intent into working software faster, if the expert still owns the result.
Old software is often trapped value
In Tao’s account of the experiment, he describes Java 1.0 applets from the late 1990s that helped people visualize ideas in complex analysis and linear algebra. The web moved on, browser support disappeared, and the applets became effectively dead.
While migrating old web and blog material into a more maintainable repository, he asked a modern coding agent to port the applets to JavaScript. Roughly two dozen old applets became functional again in hours, with some graphical upgrades.
The numbers are small, but the operating pattern matters.
Most companies have their own version of this problem:
- useful internal tools trapped in outdated frameworks
- prototypes that were never polished
- calculators living in spreadsheets
- admin workflows only one person understands
- small client tools that were too expensive to rebuild properly
Before coding agents, that backlog often failed the cost test. The work was too fiddly for a senior engineer, too risky for a junior engineer, and too boring to compete with roadmap work.
Coding agents change that equation. They are not magic senior engineers. They are force multipliers for well-scoped modernization.
The pattern works when the target is inspectable
The strongest candidates share a few traits: there is a clear before-and-after target, a running reference or known behavior, a small surface area, and a reviewer who understands the domain.
That makes the work inspectable. The agent can translate, refactor, test, and document. The expert can judge whether the result still does the right thing.
Tao’s caveat is the part operators should underline. Large language model coding agents can create obvious bugs and subtle bugs. In this case, he found one minor bug in the ported applets, while the agent identified two bugs in the original code.
That is encouraging, but it is not a permission slip. The experiment worked because the output was visible, the domain expert could test the behavior, and the blast radius was low.
The same pattern would be much riskier in a payment system, a permissions service, or a workflow where wrong output can quietly survive for months.
Build a modernization lane, not an autonomy fantasy
Teams hear a good coding-agent story and jump straight to autonomous delivery. That skips the most valuable near-term use case.
Create a controlled modernization lane instead.
1. Pick stale tools with visible behavior
Port an old calculator. Rebuild a small dashboard. Turn a manual worksheet into a focused internal app. Start where a reviewer can compare the new result with a trusted reference.
2. Make the agent show its work
Require tests, migration notes, assumptions, and a list of behavior it could not verify. A working demo is not enough. The review package matters because it turns output into evidence.
3. Keep domain review as the release gate
The person who understands the workflow should run the tool before it reaches customers or critical operations. Engineering review can confirm code quality. It cannot always confirm that a mathematical model, pricing rule, or operational decision is correct.
4. Match controls to blast radius
A revived visualization can tolerate a different review process from a tool that writes customer records. Increase test depth, approval, logging, and rollback requirements as consequences rise.
Expertise gets more leverage, not less value
Tao also used the agent to build new visualizations for special relativity and Gilbreath’s conjecture. That is the more durable signal. Experts can now create interactive explanations and small tools that used to be too time-consuming to justify.
For education, research, product demos, and internal training, that matters. So does the risk. A coding agent can accelerate the path from idea to working artifact, but it can also create confident, broken behavior when nobody checks the edge cases.
The operator takeaway is simple: do not ask coding agents to replace expertise. Point them at the backlog where expert review already exists but engineering time is scarce.
That is where the economics get interesting. Not because the agent is perfect, but because the expert can finally afford to build the tool they always wanted.