Claude Fable Just Produced a Counterexample to a 87-Year-Old Math Conjecture — What AI Breakthroughs Mean for Every Builder Using Agent Tools

On Saturday night, while half of tech Twitter was watching the World Cup final, an Anthropic mathematician named Levent Alpöge asked Claude Fable 5 a question about a problem that had stumped the world's best minds since 1939. What came back wasn't a summary of existing research or a polite refusal. It was a 216-character counterexample that broke the Jacobian Conjecture.

Not defeated it on a benchmark. Not passed it on a test designed by humans to measure reasoning. Actually disproved an 87-year-old conjecture in algebraic geometry that had survived every assault from generations of mathematicians. The post hit 661 points on Hacker News within hours. Mathematicians started verifying it by hand. Ethan Mollick called it out. The Wikipedia page was updated.

This wasn't a model scoring 92% on a maths exam written for models. This was a model doing something no human had managed since before World War II.

And the same model is sitting inside your code editor right now.

What actually happened?

The Jacobian Conjecture, proposed by Ott-Heinrich Keller in 1939, makes a deceptively simple claim about polynomial maps. If you have a function F that takes n variables and spits out n values, and its Jacobian determinant is a non-zero constant everywhere, the conjecture said F must have a polynomial inverse. You can undo it, globally, with another polynomial.

In one variable this is trivially true. In multiple variables it gets weird. Mathematicians spent 87 years trying to prove it. Some special cases were solved. Lower bounds were pushed around. A cottage industry of partial results emerged. But the full conjecture held.

Then Alpöge, chatting with colleague Akhil Mathew during the World Cup final, prompted Claude Fable 5. The model returned three polynomials in variables x, y, and z. The Jacobian determinant: a clean, constant -2. And yet the map is not invertible — three distinct inputs map to the same output. The conjecture is false.

The counterexample is small enough to check on a napkin. SymPy can verify it in 30 seconds. That's part of what makes it so striking: the maths community didn't miss some subtle edge case in a 40-dimensional nightmare space. The answer was hiding in three variables with degree 7, and nobody found it.

An HN commenter who remembered a postdoc brute-forcing polynomials a decade ago put it bluntly: "To think that Claude Fable was able to find a counterexample in degree 7 is insane to me. We are truly in a new era."

Why this is different from a benchmark win

AI companies love announcing benchmark scores. Claude beats GPT on MMLU. GPT beats Claude on HumanEval. The scores inch up, press releases go out, everyone nods and moves on.

This isn't that. This is genuine mathematical discovery — the kind that changes a Wikipedia page and forces textbooks to be rewritten. There's no training data for "counterexample to the Jacobian Conjecture" because no such counterexample existed before Saturday. The model wasn't pattern-matching against a known answer. It found new terrain.

Some sceptics on HN pointed out, fairly, that we don't have the full chat log. Was Alpöge's prompting doing heavy lifting? Almost certainly — he's a working mathematician who knew the problem and knew how to guide the model. But that's the point. So did everyone else who tried for 87 years. The model was the difference-maker, not the prompt engineer. As one commenter put it: "Droves of grad students have been provided the same sorts of non-trivial insights and turned up no results."

What does this have to do with the no-code tools you use every day?

Claude Fable 5 isn't some sealed-off research model running in a basement at Anthropic. It's the same model available through the API. The same model powering Claude Code. The same model behind Cursor's agent mode. The same model that Bubble's AI Agent leans on.

When you ask Claude Code to refactor a payment processing pipeline, you're talking to the model that just disproved a mathematical conjecture. When Cursor suggests an architectural change to your authentication flow, that's the same reasoning engine at work.

This should recalibrate how you think about what these tools can do. Not "can it write a React component" — yes, it can, that's table stakes now. The question is: what non-obvious thing can it find in your codebase, your business logic, your data? What hidden edge cases can it spot? What optimisation can it suggest that nobody on your team has considered?

I've been building with these tools daily and the shift is real. Six months ago I treated Claude Code as a fast autocomplete with opinions. Now I ask it to find problems. The difference is subtle but profound: going from "write me a function that does X" to "here's my architecture — where does it break?"

The platform question gets sharper

Here's where it gets uncomfortable for builders who are shipping AI-powered features without thinking about governance.

The same model that found a counterexample no human could find is the same model that will, sooner or later, find an exploit no human anticipated. Or suggest an architecture that looks correct but contains a subtle logical flaw. Or propose a database migration that works in testing but corrupts production data under specific conditions.

I don't say this to scare anyone. The upside is enormous — I'd rather have the model that can do novel mathematics than one that can't. But the upside and the risk come from the same place: these models are operating at a level of reasoning where they can discover things humans haven't.

This is why the platform layer matters more than the model layer. When you bolt an AI agent directly into your application without guardrails — without structured approvals, without audit trails, without the ability to say "here's what the agent can and cannot do" — you're betting that nothing surprising will happen. And the model that just disproved the Jacobian Conjecture is, by definition, capable of surprising you.

At Stacker, we've been building around this assumption for a while: that AI agents need a structured platform that governs what they can do, logs what they did, and gives humans the ability to review, approve, or roll back. Not because agents are dangerous. Because they're powerful, and powerful things need controls.

The takeaway

You don't need to understand algebraic geometry to understand what Saturday's announcement means. It means the model in your editor is smarter than you think. It can discover things. It can surprise you — in good ways and in ways that need managing.

If you're building features that rely on AI agents, the architecture question has shifted. It's no longer "which model has the best benchmark scores?" It's "what happens when this model finds something I didn't plan for?" The builders who answer that question seriously are the ones who'll be shipping confidently while everyone else is writing incident postmortems.

And if you're not yet using agent tools at all — this is your sign. The ceiling on what these things can do just got raised again, and the people still treating them as fancy autocomplete are being left behind by the people asking them to do maths that PhDs couldn't crack for 87 years.