One of the most profound shifts in my thinking has been realizing that mastery is not merely about knowing more facts—it is about performing less unnecessary computation.
This realization did not come from reading a textbook. It emerged gradually through years of solving technical problems, observing people, and refining the way I work.
The World as Computation
Increasingly, I find myself viewing everyday life through a computational lens.
Every person operates under constraints:
- Limited time
- Limited attention
- Limited memory
- Limited energy
- Limited computational capacity
Whether we are engineers, managers, teachers, or IT support professionals, we constantly face the same challenge:
How can we achieve the greatest outcome with the least unnecessary computation?
This applies not only to computers but also to human thinking.
Solving Problems Is Only the Beginning
Early in my career, when someone reported a technical issue, my first instinct was usually to connect remotely to their computer or physically visit their workstation.
I wanted to inspect everything myself.
Today, my approach is very different.
Instead of beginning with the solution, I begin by reducing uncertainty.
If a user reports an application error, I might ask only a handful of questions:
- What exactly is the error message?
- When did it begin?
- Was there a power interruption?
- Did anything change before the problem occurred?
Each question is carefully chosen because it eliminates many possible explanations at once.
Rather than wandering through hundreds of possibilities, the problem converges rapidly toward a likely cause.
The process reminds me of numerical methods for solving equations, where each iteration dramatically reduces the remaining uncertainty instead of blindly searching every possibility. It is as though the algorithm progressively constrains the search space until the answer is effectively trapped.
Good troubleshooting is not about asking more questions.
It is about asking better questions.
Computation Can Be Moved
One lesson I have learned is that computation does not disappear.
It simply moves.
Instead of repeatedly thinking through the same problem, I invest time creating concise user guides.
A recurring issue becomes a two-page PDF.
The PDF becomes searchable.
The search becomes nearly instantaneous.
Instead of remembering every detail, I remember where the detail lives.
The computation has moved from my working memory into documentation.
This is one of the most powerful productivity improvements I have experienced.
External Memory
I organize my documentation with consistent naming conventions and searchable keywords.
Using a fast indexing tool, I can locate a guide within seconds.
The interesting part is that I know how I think.
When I search, I instinctively know which keywords I would have used when I originally wrote the guide.
Even months later, retrieval feels almost effortless.
Instead of reconstructing a solution every time, I retrieve a previously compressed form of knowledge.
Knowledge becomes an extension of memory rather than something that must constantly occupy it.
Levels of Abstraction
Perhaps the biggest insight has been understanding that problems can be solved at many different levels.
The first level is solving an individual problem.
The second level is teaching the user how to solve it.
The third level is teaching supervisors so they can help others.
The fourth level is documenting the solution.
The fifth level is redesigning the system so the problem rarely occurs in the first place.
Each higher level reduces future computation.
Instead of repeatedly solving individual cases, one improvement benefits hundreds of future situations.
This is what I like to think of as creating “sums of sums.”
Rather than adding individual solutions together, I search for a higher-level solution that contains many smaller solutions within it.
The Humbling Nature of Abstraction
Years ago, whenever I discovered a powerful idea, I often felt I had reached the deepest understanding available.
Experience has taught me otherwise.
Every framework eventually becomes part of a larger framework.
Every abstraction eventually becomes a special case of an even broader abstraction.
This realization has been deeply humbling.
It has changed the way I think about knowledge.
Instead of searching for the ultimate explanation, I now expect that future experience will reveal an even higher level of organization.
Rather than discouraging me, this has made learning more exciting.
There is always another layer waiting to be discovered.
Perhaps that is one of the defining characteristics of knowledge itself: every abstraction that seems complete eventually becomes a component of a larger one.
Moving Less
One observation stands out more than any other.
As my understanding has improved, I find myself moving less.
Not physically.
Mentally.
Problems that once required long investigations now require only a few carefully chosen questions.
Many solutions already exist in documentation.
Many recurring situations have already been generalized.
It is almost as if my previous thinking has been compiled into reusable building blocks.
The goal is no longer to think harder.
The goal is to think once, organize the knowledge well, and reuse it indefinitely.
Final Thoughts
Perhaps expertise is not about accumulating endless information.
Perhaps it is about continually discovering higher abstractions that compress complexity into simpler, reusable forms.
Every good abstraction reduces unnecessary computation.
Every good document saves future thinking.
Every good process prevents future work.
Perhaps civilization itself advances in the same way—not merely by producing more knowledge, but by compressing that knowledge into forms that future generations can retrieve, understand, and build upon with ever less effort.
In the end, intelligence may not be measured by how much computation we perform, but by how elegantly we eliminate the need to perform it again.
