Learning to use a new app or system can be intimidating. If it’s a complex system, you have a lot of essential concepts to understand upfront. Some may seem familiar but are used in unexpected ways. You have things you want to do but don’t yet know how to go about it.

Initially, your goal is to develop a mental model that allows you to use the system to do useful things. The model needn’t be perfect at first. That would take too much time. For now, you simply want to get things done. You want a model that is good enough to get you going — one that satisfices.

But you shouldn’t stay with “good enough” forever. Once you’ve mastered the basics, you can flex your skills and find out what else you can do. This may involve doing new things with the system, but it could also be about doing existing things better or more efficiently.

How do you go about it? The obvious answer is to dig deeper into the system’s more obscure functions to learn about the details you missed at first. In doing so, you look to further develop your mental model. At first, you’re sketching the model with broad brushstrokes, but eventually, you want to use a fine brush.

That’s one way to do it, but it’s not the only way. I’ve discovered a somewhat contrarian approach that works wonders for me: Once I’ve achieved basic competence with the system, I go back to first principles and revisit the basics. After understanding its basics, re-learning the system reinforces my grasp of crucial concepts and reveals points I missed in my early rush to learn the thing.

This approach works especially well if I use a different medium to learn about the system than what I used to get started. For example, if I first learned to use an application from its built-in onboarding instructions, after some time, I might read a book or watch a YouTube video produced by a third party. Seeing the system through other people’s perspectives helps me understand important points I missed at first, perhaps because I was too focused on getting to do the thing I first signed up for.

This may sound abstract, so I’ll give you a concrete example. I use an amazingly rich and deep personal knowledge management application called DEVONthink. It’s a complex system, and it took me a couple of years to feel confident that I was using it “right.” Now DEVONthink is a natural and integral part of my workflows.

But over the past week, I did something that might seem unusual: I started going through an introductory course on DEVONthink.1 I’m learning many useful things that have been there all along but which had eluded me. I’m halfway through the course, but I can already tell that I’m going to come out the other end making much better use of this tool.

What’s going on here? Why would going back to basics deepen expertise? I have a few hypotheses. For one, when I first started using DEVONthink, I was concerned with how it mapped to other applications I already understood. In particular, I compared it to other personal knowledge management systems such as OneNote, Yojimbo, and the macOS Finder. At first, I couldn’t see much of what was unique about DEVONthink because I was concerned with what I thought I already knew.

Richard Saul Wurman said, “you only understand something relative to something you already understand.” It’s true: when learning something new, you must scaffold new concepts atop things you already know. But the new structure must eventually stand on its own — i.e., if the structure is to carry weight, you must dismantle its scaffolding. This dismantling can take time.

For another, I first came to DEVONthink with a particular use case in mind. My initial exploration of the system focused on a relatively small set of features that supported that use case. By necessity, this meant ignoring lots of other features that could be helpful, but which at that time were distractions. (DEVONthink has lots of features, and with lots of features comes complexity.) But now that I’ve mastered the app for my original use case, I’m more receptive to exploring other capabilities.

Finally, at this point, my mental models for how personal knowledge management systems should work have changed as a result of working with DEVONthink itself. I.e., I no longer compare DEVONthink to other apps in the space; DEVONthink has now become the referent. As such, I now listen for fundamentals through an ear that is better attuned to the system’s particular ways of organizing its subject domain. In other words, I’m a better pupil now that I’m no longer a total noob; I’m more receptive to basics I missed the first time around.

Whatever the case, I’ve experienced this pattern many times in my life:

  1. Struggle to acquire basic skills,
  2. Gradually deepen those skills,
  3. Develop some degree of mastery, and
  4. Re-learn the basics.

Getting to step 4 takes my level of competency to a much higher level. And it works for many subject domains, not just learning complex software. Now that I recognize the pattern, I look to set up opportunities to revisit the basics after achieving some degree of competence with a subject. Doing so invariably leads to new insights and creates opportunities for further development.

  1. David Sparks’s DEVONthink Field Guide, which I recommend highly. I’ve signed up for another of David’s courses, and will likely do a third. ↩