Terry Tao on Coding Agents: Old and New Apps via LLMs

When a Fields Medalist like Terry Tao sits down to experiment with AI coding agents, the results are worth paying attention to—not just for the novelty, but for the nuanced perspective he brings to what LLMs can and cannot do. His latest blog post, "Old and new apps, via modern coding agents," is a refreshingly grounded take on using tools like Claude to build interactive visualizations, and it has sparked a lively discussion on Hacker News.

Terry Tao's Experiment with AI Coding Agents

In his post, Tao describes using Claude to recreate an old app he wrote in 1995—a bitwise calculator for illustration purposes—and to create a new interactive visualization for a recent paper on parity incidence. The parity visualizer helps readers explore the behavior of functions over a grid, making the paper more accessible.

Tao notes that the coding agent was remarkably productive: "I was able to generate the interactive visualizations for these two applications in a matter of a few hours, with the agent doing the heavy lifting of writing the code." But he also carefully delineates the boundaries. As he writes near the end: "as such [LLM-coded interactive] supplements are not mission-critical to the core of the paper, I again feel that the downside risk of using guided interaction with LLM agents to generate such visualizations is acceptable." That last sentence is the key: he sees these tools as worthwhile for non-critical supplements, not for core contributions where correctness is paramount.

Tao's examples are simple, self-contained HTML+JS apps—perfectly suited to the current strengths of LLMs: small, interactive, and visual. He does not claim these are production-grade; rather, they are pedagogical aids.

The Hacker News Reaction

The Hacker News community reacted with a mix of amusement and admiration. One commenter joked: "Terry Tao using coding agents to build apps means we're one step away from a Fields Medalist asking an LLM why his Docker container won't start, just like the rest of us." Another quipped: "Terry Tao using coding agents feels like watching a Michelin-starred chef discover microwave dinners and get genuinely excited about them."

But beneath the humor, there was serious discussion about the potential. One user wrote: "There is infinite latent demand for software, most especially outside the traditionally software-focused spaces. If LLMs stopped improving today it would take us 10 years to catch up to the new software-writing abilities that have become available. This is a great illustration of that fact."

Another commenter, an educator, shared their own experience: "Building visualizations with LLMs has been a major boost for my CS classes. Many visualizations that I have always wanted but just didn't have the time to build, I now have." They linked to an essay on htmx and a teaching computer project built in a few days with Claude.

Key Takeaways for Educators and Researchers

Tao's post is important because it comes from someone with towering credibility who is neither a hype man nor a skeptic. He uses the tools, observes their strengths and weaknesses, and offers a clear risk calculus.

What strikes me is the pattern: LLM-generated code is excellent for supplemental software—demos, visualizations, quick prototypes—where a bug means a confusing graph rather than a crashed rocket. In these contexts, the productivity gain is enormous. Tao built two apps in hours that would have taken days or weeks conventionally. That's a 10x boost for non-critical output.

But Tao is also careful to note that he guided the agent heavily, iterating on prompts and reviewing every line. This is not "set it and forget it." The human-in-the-loop remains essential. The real value is in accelerating the exploration of ideas, not in automating production.

I think the biggest impact will be in fields like education, data journalism, and early-stage research, where quick visual feedback is more important than perfection. LLMs can turn a back-of-the-envelope sketch into a working interactive chart in minutes. That's genuinely new.

When to Use LLM-Generated Code (and When Not To)

If you're building tools or content, here are concrete ways to apply this:

• Educators: Use LLMs to generate interactive demos for concepts like binary arithmetic, sorting algorithms, or statistical distributions. Prompt an agent to create a slider-controlled visualization in HTML/JS and iterate visually.
• Researchers: For supplementary materials (not the core algorithm), consider using coding agents to create interactive figures for your papers. Tao's parity visualizer is a perfect template.
• Prototyping: When exploring a new feature, spend 30 minutes with an LLM to generate a fake backend response and a frontend mockup. It's faster than mocking up in Figma for some tasks.
• Know when NOT to use: Do not use LLMs for security-critical code, financial calculations, or any place where a silent error could be dangerous. Tao's rule—"not mission-critical"—is a good guideline.

Here's an example of what a prompt for an LLM might produce: a simple parity visualizer in HTML.

<!DOCTYPE html>
<html>
<head><title>Parity Visualizer</title></head>
<body>
<canvas id="c" width="400" height="400"></canvas>
<input type="range" id="threshold" min="0" max="255" value="128">
<script>
const canvas = document.getElementById('c');
const ctx = canvas.getContext('2d');
const size = 40;
function draw(threshold) {
  for (let x = 0; x < 10; x++) {
    for (let y = 0; y < 10; y++) {
      const n = x * 10 + y;
      ctx.fillStyle = n % 2 === 0 ? 'blue' : 'red';
      ctx.fillRect(x * size, y * size, size, size);
    }
  }
}
draw(document.getElementById('threshold').value);
</script>
</body>
</html>

This is a quick, dirty, but functional demo. You'd refine it for a real paper, but for exploration it's gold.

Final Verdict

If you're an educator, researcher, or anyone who needs to communicate ideas through interactive visuals, coding agents are a game-changer for lowering the effort bar. If you're building critical infrastructure or shipping production code where correctness is legally required, proceed with extreme caution and treat LLM output as a first draft, not a final answer. For the rest: try it. Spend an afternoon building a visualization for a project you've been putting off. You might surprise yourself.

---

Read the original post on Terry Tao's blog and join the discussion on Hacker News.