There is a puzzle that illustrates something I've been thinking about for a long time.
A man enters a tunnel. When he's at one quarter of it, he hears a train outside — about to enter from the same end he came from. He knows two things: if he runs back the way he came, he'll just make it out before the train catches him. And if he keeps going forward, he'll just make it out the other end before the train catches him there too. What is the ratio between the train's speed and his?
Most people reach for algebra. Call the tunnel length 1, his speed v, the train's speed V, the train's initial distance from the entrance d. Write two equations, one for each scenario. Subtract them. Get V/v = 2. The train is twice as fast.
That works. The answer is correct. But it reveals nothing.
Here is the other way. Imagine there are two men, starting at the same point at the same moment. One runs back. One runs forward. When the first man reaches the tunnel entrance — just as the train arrives there — where is the second man? He has been running for exactly the same amount of time, but in the opposite direction. He started at 1/4 and has covered another 1/4. He is at the halfway point.
Now the picture is clear. The train is at the entrance. Man #2 is at the midpoint. He just makes it to the far end. So the train covers the full tunnel in the same time man #2 covers half of it. The train is twice as fast.
No equations. No variables. The answer is the same — but now you can see why.
- The tunnel puzzle: why brute-force algebra, though correct, reveals nothing — and the construction that does
- Pass 1 (truth) vs. pass 2 (understanding) — how the second pass is honest precisely because it comes after
- The same move across mathematics, physics, software, and finance — from Gauss to Black-Scholes
- How second-pass insights compound into a toolkit that makes future first passes faster
- Why not every result has an elegant version — and why the search is almost always worth attempting
Truth First, Understanding Second
The mythology around mathematical insight is that the elegant understanding comes first. Poincaré steps onto a bus and suddenly sees the structure. Ramanujan's formulas arrive in dreams. The intuition is presented as prior to the calculation — the proof merely confirming what genius already knew.
For most people, most of the time, it goes the other way. You grind through the equations, get the answer, and then — if you're disciplined enough to go back — you ask: why is it 2? What is the thing that made this inevitable? What construction, if I had seen it first, would have made the answer obvious?
This is the second pass. And admitting that it comes second is important, because it means the skill is learnable in a way that "have the insight first" is not.
The two passes have different goals:
Pass 1 is about truth. You use whatever machinery is available — equations, models, brute force, hardcoded implementations. You are not looking for elegance. You are looking for a correct answer. The standard is: does it work?
Pass 2 is about understanding. Now that you know the answer is right, you go looking for the construction that makes it obvious. You work backwards from the destination. The standard is: does this reveal why?
Pass 2 is only honest because of pass 1. When you find the two-man construction after solving the algebra, you are not inventing a pretty story. You are excavating the structure that was always underneath. The brute force result is what guarantees the elegant version isn't fiction.
This is also why pass 2 feels so different from pass 1. The first pass is a slog toward an unknown destination — every step is uncertain. The second pass is exploration of known territory. You can't get lost because you already know where you're going. The answer is your anchor, and the freedom that comes from having it is what makes the elegant construction findable.
A Pattern Across Domains
Once you start looking for the second-pass move, you find it everywhere.
In mathematics, proofs by induction often work but reveal nothing. The identity that the sum of integers from 1 to n equals n(n+1)/2 is provable by induction in a few lines. But the insight is Gauss pairing the sequence with its reverse — writing it forwards and backwards, adding column by column, seeing that every column sums to n+1 and there are n columns so the total is twice what you want. The induction is pass 1. Gauss's construction is pass 2. One confirms. The other illuminates.
Euler's formula — that e raised to iπ plus 1 equals 0 — can be derived analytically from power series. The derivation is correct and unilluminating. The insight, which comes after, is that the formula is about rotation in the complex plane — that multiplying by e to the iθ rotates a point by angle θ. Once you see that, the formula stops being a magical coincidence and becomes an obvious fact about the geometry of complex numbers. The derivation got you the answer. The geometric picture is what you actually understand.
In physics, Feynman was famous for this practice. He would encounter a published proof, find it correct but unsatisfying, and go find his own path to the same result — one that made the answer feel inevitable rather than derived. The principle of least action produces the same predictions as Newton's laws, but it reveals something Newton's formulation hides: that nature, in some sense, finds the path of least resistance through possibility space. Newton tells you how. The Lagrangian formulation hints at why.
Dimensional analysis is a second-pass tool of a different kind. You run the complex model, get a number, and then ask: can I recover this from units alone? When you can — when the answer turns out to depend only on the fundamental quantities in a way that dimensional reasoning makes obvious — you understand not just the result but what the result actually depends on.
In software, the parallel is exact. You write the code that works first. You don't worry about abstraction or elegance or removing the hardcoded values. You get from the beginning to the end. You have your proof of concept — your pass 1. Then, once it works, you refactor. You find the abstraction that was hiding in the hardcoded repetition. You name the concept that was implicit in the structure. You remove the things that were scaffolding and keep the things that are architecture.
The refactored code isn't more correct than the original. But it reveals what the code is actually doing. It makes the structure legible. And — crucially — it makes the next problem easier, because the abstraction you found is now available to reach for.
In quantitative finance, the Black-Scholes formula can be derived through stochastic calculus — a technically demanding pass 1. The insight that comes after is that you are pricing a replicating portfolio: the option is worth whatever it costs to dynamically hedge it, and the formula is just the cost of that hedge expressed analytically. Once you see that, the formula is no longer a mathematical artifact. It is a statement about what an option actually is. The derivation got you the number. The replication argument tells you what the number means.
Risk attribution works the same way. You run the complex model, get the P&L decomposition, and then ask: what is the one-line explanation? What is the factor that actually drove this? The model gives you the answer. The explanation you construct afterward is what makes the answer useful to a trader at seven in the morning.
Building a Toolkit of Constructions
There is a compounding benefit to the second-pass discipline that goes beyond understanding any individual result.
Every time you successfully unbruteforce something, you add a construction to your toolkit. The two-man trick is not just the solution to the tunnel puzzle. It is a reusable move: whenever you encounter a problem with two symmetric scenarios and a shared constraint, you reach for it. The insight retroactively becomes intuition — available before the algebra next time, because you did the algebra once.
This is how mathematical maturity actually develops. Not by memorizing more techniques, but by accumulating constructions — auxiliary objects, geometric pictures, reframings — that make classes of problems transparent. The mathematician who has seen a hundred problems doesn't solve the hundred-and-first faster because they compute faster. They solve it faster because they recognize the structure, and the structure reminds them of a construction that dissolves the problem.
The goal of the second pass isn't just to understand this result. It's to make yourself smarter for the next one.
The same is true in software. The abstraction you find in refactoring one codebase becomes the pattern you reach for in the next one. The naming that made one system legible trains your eye for what's implicit and unnamed in the next. The second pass on each problem is an investment in the first pass of future problems.
The Honest Constraint
The second-pass discipline comes with an important caveat: not every brute force result has an elegant version waiting to be found.
Some things are just complicated. Some calculations resist intuition not because the right construction hasn't been found yet, but because the result genuinely depends on an interplay of factors that cannot be compressed further. The multivariate dependencies are real. The interactions are not decomposable. The elegant version would be a lie — a simplification that feels satisfying but distorts.
Knowing when to stop looking is part of the discipline. The second pass is a search, not a guarantee. Sometimes the most honest thing you can say is: the calculation gives the answer, and the calculation is the understanding.
But the search is almost always worth attempting. Even when it fails, the attempt sharpens your sense of what the result actually depends on — which factors could change it, which couldn't, where the complexity is essential and where it's incidental. The failed second pass is rarely wasted.
And when it succeeds — when the construction appears and the answer suddenly seems like it couldn't have been anything else — the satisfaction is of a particular kind. Not the relief of a correct answer, which pass 1 provides. Something closer to recognition. The sense that you have seen, briefly, the shape of something that was always there.
That seems worth going back for.
For how engineering culture often rewarded pass-1 recall over pass-2 judgment — and what happens when that recall becomes cheap — see Good Judgment Under Ambiguity.