A junior developer ran the program, and a stack trace fifty lines deep appeared.
The junior cried, “There are so many places where this went wrong!”
The senior developer asked, “Did the error happen in fifty places, or in one?”
The junior pointed to the topmost line.
The senior smiled. “And from where did that line learn its mistake?”
The Path Reveals Itself
A stack trace can feel like an accusation — fifty lines of evidence that the code has failed, each one pointing a finger at somewhere else. The junior developer sees a catastrophe spread across the call stack. The senior developer sees a single moment of failure, echoed backward through time.
This is the first teaching of the koan: what looks like many problems is almost always one problem, wearing many faces. The stack trace is not a list of fifty errors. It is a single error telling the story of how it traveled through the system to reach you. Reading it from the bottom up is reading a history. Reading it from the top down is reading a confession.
The second teaching is quieter. The senior developer does not ask “what went wrong” — they ask where the mistake was learned. Every line in a call stack was called by another line. Every assumption was passed down from somewhere. The error did not appear from nothing; it was taught, step by step, by the logic that preceded it. To fix only the top of the stack is to silence the messenger. To follow the question downward — “and from where did that line learn its mistake?” — is to find the place where the teaching itself went astray.
For the mindful developer, this is a practice available every time something breaks: resist the noise of the stack, find the one true place, and then ask not just what failed, but what caused it to believe it was doing the right thing.