Experts unlearn and simplify.
I’m finding that any time I’m approaching any kind of intermediate or “expert” state in a field (which happens extremely rarely), I start a process of unlearning and simplification.
The meme below comes to mind in this particular context, of course replacing the IQ axis with the amount of knowledge one accumulates when learning:
- when you start and know nothing, you only make very simple assumptions and come up with simple solutions;
- the more you learn, the more your start adding complexity to your ideas and projects, you try everything, you iterate on your work without giving too much thought to what to discard, simplify, or remake;
- finally, if and when you become an expert, you go back at simple solutions because you can now see beyond the complexity, you can induct (more on this later) universal principles, and you can ignore counter-productive solutions masked as help.
That last point, the unlearning process, naturally follows the learning part because as beginners we intuitively focus on “accumulating” knowledge rather than finding patterns and discovering universal principles.
You become an expert when you start crystallizing knowledge into those simple core principles from which everything else stems.
It’s like shifting from a deduction mindset to an induction one:
- when you start, you learn a ton of stuff and memorize principles and rules to follow; when you apply them, you deduct solutions to your problems based on these rules and laws you learned;
- when you’re finally starting to master the new skills, you use your new “muscle memory” and automatic behaviors to infer principles and rules on your own and find patterns that are meaningful to you.
Masters of their crafts come up with principles and rules themselves.
For example with programming, it’s common for beginners’ code to be convoluted and hard to understand. My co-founder Francesco (an expert full stack developer) often corrects me to simplify my code and remove useless complexity. In fact producing clean, simple, and reusable components is one of the most satisfying things to be able to do for a beginner developer.
As another even more personal example, I’ve spent years studying, learning, and researching how stories are developed out of personal interest. I’ve read McKee, Truby, and the rest of them and took copious notes about storytelling. I finally started mastering some little aspects of storytelling (but I'm still as far from an expert as one can be) when I put aside most of the notions and started seeing the bigger picture, reasoning from “first story principles” myself (what drives almost all stories? Why? What universal principles do I personally find the be true?) or coming up with my own principles. And you can come up with this kind of insights only if you can put aside the theory you've learned.
One final thought: in the learning process, projects often become complex and convoluted. Trying to improve them is a burden and sometimes counterproductive.
When I tried just starting from scratch, the work usually took half the time, with results that were much cleaner and better in any way.
You shouldn’t ever be afraid to start over; it’s almost always for the better and will help clarify and solidify new knowledge and expertise.