When AI Reaches the Summit First in Math — A Hybrid of Step-by-Step Understanding and Delayed Learning

On September 8, 2026, OpenAI announced that an internal model had found a finite-time singularity in the 3D Navier–Stokes equations, one of the Clay Mathematics Institute’s Millennium Prize Problems, each carrying a US$1 million prize. According to the reporting, a group of roughly 10,000 autonomous agents reached the result in about 88 hours (around three and a half days), and spent another 17 hours formalizing and verifying it in Lean (Quanta Magazine, AIwire). A problem that AIwire’s headline describes as unsolved for 90 years was closed off in three and a half days.

A month later, on October 6, 2026, OpenAI released a batch of 722 paper drafts in 372 families, all generated by an internal model, to a GitHub repository in one shot. Among them: a proof of the “quasi-Riemann hypothesis,” showing that every Dirichlet L-function, including the Riemann zeta function, has no zeros with real part greater than 7/8 (a partial result that widens the known zero-free region, not the Riemann hypothesis itself), and a claimed resolution of the Hausdorff-dimension Kakeya conjecture in four dimensions. Not everything is formalized: after three manuscripts were withdrawn on October 7, the repository reports 300 of 719 top-line results (about 42%) formalized in Lean.

What stuck with me across both announcements was not the results themselves but how they were reached. The intermediate reasoning is verifiable as a Lean proof, but it is not laid out in a form a human can retrace line by line and feel they have climbed alongside. IEEE Spectrum’s coverage and WIRED’s September story describe a credit dispute: the Navier–Stokes announcement intersected with independent earlier blow-up work by Tristan Buckmaster (NYU) and Levent Alpöge. WIRED’s October story adds the backlash against OpenAI publishing on blogs and GitHub rather than through peer review, and reports, citing a person familiar with his thinking, that OpenAI’s Sébastien Bubeck appears to believe the company’s technology will swiftly end most mathematicians’ careers.

An AI That Steps Through a Portal to the Summit

Watching outputs like this, the experience is less “the AI climbed the mountain faster” and more “I turned around and the AI was already at the summit.” Not a faster climb, but something closer to arriving at the top without the climb in between.

An October 2026 guest post by Jeremy Avigad on Terence Tao’s blog, The Future of Mathematics, uses a backpacking analogy. It imagines a backpacking trip into the Alaskan wilderness: letting AI book the flight to the trailhead is fine, because the trip’s value does not come from booking logistics; but if AI does the hike for you, the trip has lost the thing you went for.

Tao himself keeps returning to the idea of “proof indigestion,” which he lays out in his ICM 2026 lecture slides and lists among the sources on his page summarizing his views on AI in mathematics. Generating proofs and verifying them are being automated well; the stage where a human reads the proof, digests it, and connects it to other theorems is being left behind. The AI can show it reached the summit; the human has not yet digested how the climb went.

The same shape shows up in code and product work. When a coding agent returns a diff in minutes and the tests pass, CI can be green while you still have not reconstructed, in your own head, why this is the right implementation. Reviewing and accepting a diff is one task; absorbing the diff into your own understanding is another. A green CI does not finish the second one.

In an earlier post about the three-layer team setup I wrote about splitting work into advisor, decision, and execution layers. That post was organized around “what the human needs to decide” and did not spell out “how the human learns from an answer the AI reached before they did.” This post is the follow-up: how I handle what comes back from the advisor and execution layers, split into two learning modes.

Step-by-Step Mode: The Human Reconstructs the Climb

The first mode is the one humans have always used: build understanding incrementally. Read from the premises forward, evaluate each branch yourself, and reconstruct the route to the conclusion inside your own head.

This mode fits when:

A wrong call has broad consequences: permissions, billing, external sends, product value judgments. These are the decisions I kept on my side in the three-layer setup
You are accountable to someone else for the result: customers, candidates, community members, management decisions, anywhere you have to articulate the reasoning to a third party
You have no working hypothesis in the domain yet: cases where you want to internalize “why does this hold” to reuse later in adjacent problems

In this mode, AI outputs are treated as candidates. Even if the model has stepped out at the summit already, the human climbs the same route with the advisor layer alongside, pauses at each branch, and evaluates the forks. It takes several times longer than letting the AI finish alone, but you get decision quality and transferability to other projects.

Delayed-Learning Mode: Take the Summit First, Learn the Route Later

The second mode receives the AI’s conclusion first and recovers the route afterward.

This mode fits when:

A wrong call is local and easy to roll back: one-off refactors, scripts, drafts, any diff whose cost does not cascade elsewhere
You are under a tight time constraint: routine work where you need throughput, or the first pass on a research question where you want wide coverage fast
Deferring your own learning cost is acceptable: cases where getting the deliverable moving matters now and understanding can land later

In this mode the human’s job is to compress what the AI returned into something future-you can retrieve. For code, that means writing the design decision back into the SKILL.md as you read the diff, or boiling it down into a short note or post. In mathematical terms, it is doing the proof digestion step Tao talks about, as an explicit scheduled activity rather than a hoped-for byproduct.

The trap in this mode is treating “CI passed” or “the review landed” as the end of learning. If you skip the delayed-learning step, the next time a similar problem lands you will throw it at the AI from scratch again, having learned nothing durable in between.

Switching Between the Two

Day to day, I pick between these two modes per task. Three questions decide which side it lands on.

flowchart TD
  Q1{"Am I accountable to explain this to someone else?"}
  Q2{"Will I reuse this reasoning on a different task?"}
  Q3{"Is a mistake rollbackable in one review?"}
  Q2b{"Will I reuse this reasoning on a different task?"}
  Build["Step-by-Step Mode<br/>Human reconstructs the climb"]
  Delayed["Delayed-Learning Mode<br/>Ship first, learn after"]
  Either["Decide by the day's time budget<br/>and the team's workload"]
  Q3 -- No --> Build
  Q3 -- Yes --> Q1
  Q1 -- Yes --> Q2
  Q1 -- No --> Q2b
  Q2 -- Yes --> Build
  Q2 -- No --> Either
  Q2b -- Yes --> Either
  Q2b -- No --> Delayed

If the third question is No, I default to step-by-step. Permissions design, billing paths, product value judgments, these get climbed by the human even if the advisor and execution layers return a tidy answer.

If the first two are No and the third is Yes, I take delayed learning for speed. Dependency version bumps, log-format normalization, one-off scripted data migrations: apply what the AI produced, then catch up by reading the code afterward.

If the third is Yes and the first two are both Yes, I go step-by-step, since the work carries both accountability and reuse.

The tricky case is when the third is Yes and exactly one of the first two is Yes. Something you have to explain or will reuse elsewhere, but that can be rolled back in one review, could go either way, and on any given day I decide by my time budget and the team’s workload. I note which diffs went into step-by-step and which went into delayed learning during daily standups and team meetings, so individual drift gets caught before it compounds.

Small Mechanisms That Keep Delayed Learning Honest

When I pick delayed learning, these are the mechanisms I lean on to make sure the learning step actually happens.

A short per-diff note: three lines or fewer on what the diff taught, what I did not understand, what to re-check later
Weekly fold-up: cluster similar notes and compress them into one short write-up or post. This post started that way
Promote recurring judgments into skills: the Hermes Agent skill loop described in the three-layer setup post. Once a judgment is a skill, the AI can take it over on the next pass

The point of these mechanisms is to turn an AI’s answer at the summit from passive reading material into operable knowledge the human can retrieve. The proof-digestion step on the human side gets written into the operating rhythm instead of relying on willpower.

Open Problems

Running this hybrid, these are the problems I have not solved yet.

Delayed-learning debt accumulates: the weekly fold-up falls behind when the diff generation rate exceeds my learning rate
I pick the wrong mode: something I treated as delayed-learning turns out, later, to need an explanation to someone, and I have to climb it after the fact
Delayed learning interacts awkwardly with the advisor-execution split: if a plan goes to delayed learning the moment the advisor layer hands it over, I lose the premises of the plan itself

I retune one of these at a time in standups and team meetings. The recurring repair is: when “I skipped the learning step and the same domain came back a second time” happens, I move that domain back to step-by-step for a while.

Tao’s proof indigestion is about formally verified proofs humans have not yet digested. In code and product work, the same shape shows up as CI-green diffs humans have not yet digested. For AI outputs that reached the summit before I did, the operating stance is to not skip the human learning step, and to switch between step-by-step and delayed learning as I go.

That’s all from lining up OpenAI’s Navier–Stokes announcement and the October 6 batch of 722 math papers alongside Tao’s proof indigestion, and running step-by-step understanding alongside delayed learning as a hybrid for AI outputs that skip the climb, from the Gemba.

Search